From 67335178a90fbcff4fd85157477f15ef3b682b6a Mon Sep 17 00:00:00 2001 From: Garth Vander Houwen Date: Fri, 9 Sep 2022 15:07:39 -0700 Subject: [PATCH] Remaining proto updates --- Meshtastic/Helpers/BLEManager.swift | 2 +- Meshtastic/Protobufs/admin.pb.swift | 1032 +++++++++-------- Meshtastic/Protobufs/localonly.pb.swift | 26 +- Meshtastic/Protobufs/mesh.pb.swift | 654 +++++------ Meshtastic/Protobufs/module_config.pb.swift | 138 +-- Meshtastic/Protobufs/telemetry.pb.swift | 12 +- .../Config/Module/CannedMessagesConfig.swift | 16 +- .../Settings/Config/Module/SerialConfig.swift | 6 +- 8 files changed, 962 insertions(+), 924 deletions(-) diff --git a/Meshtastic/Helpers/BLEManager.swift b/Meshtastic/Helpers/BLEManager.swift index c81d535d..971aa6ae 100644 --- a/Meshtastic/Helpers/BLEManager.swift +++ b/Meshtastic/Helpers/BLEManager.swift @@ -984,7 +984,7 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph public func sendFactoryReset(destNum: Int64) -> Bool { var adminPacket = AdminMessage() - adminPacket.factoryReset = true + adminPacket.factoryReset = 1 var meshPacket: MeshPacket = MeshPacket() meshPacket.to = UInt32(connectedPeripheral.num) diff --git a/Meshtastic/Protobufs/admin.pb.swift b/Meshtastic/Protobufs/admin.pb.swift index 636d5908..708f4acd 100644 --- a/Meshtastic/Protobufs/admin.pb.swift +++ b/Meshtastic/Protobufs/admin.pb.swift @@ -31,16 +31,147 @@ struct AdminMessage { /// /// TODO: REPLACE - var variant: AdminMessage.OneOf_Variant? = nil + var payloadVariant: AdminMessage.OneOf_PayloadVariant? = nil + + /// + /// 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) + var getChannelRequest: UInt32 { + get { + if case .getChannelRequest(let v)? = payloadVariant {return v} + return 0 + } + set {payloadVariant = .getChannelRequest(newValue)} + } + + /// + /// TODO: REPLACE + var getChannelResponse: Channel { + get { + if case .getChannelResponse(let v)? = payloadVariant {return v} + return Channel() + } + set {payloadVariant = .getChannelResponse(newValue)} + } + + /// + /// Send the current owner data in the response to this message. + var getOwnerRequest: Bool { + get { + if case .getOwnerRequest(let v)? = payloadVariant {return v} + return false + } + set {payloadVariant = .getOwnerRequest(newValue)} + } + + /// + /// TODO: REPLACE + var getOwnerResponse: User { + get { + if case .getOwnerResponse(let v)? = payloadVariant {return v} + return User() + } + set {payloadVariant = .getOwnerResponse(newValue)} + } + + /// + /// Ask for the following config data to be sent + var getConfigRequest: AdminMessage.ConfigType { + get { + if case .getConfigRequest(let v)? = payloadVariant {return v} + return .deviceConfig + } + set {payloadVariant = .getConfigRequest(newValue)} + } + + /// + /// Send the current Config in the response to this message. + var getConfigResponse: Config { + get { + if case .getConfigResponse(let v)? = payloadVariant {return v} + return Config() + } + set {payloadVariant = .getConfigResponse(newValue)} + } + + /// + /// Ask for the following config data to be sent + var getModuleConfigRequest: AdminMessage.ModuleConfigType { + get { + if case .getModuleConfigRequest(let v)? = payloadVariant {return v} + return .mqttConfig + } + set {payloadVariant = .getModuleConfigRequest(newValue)} + } + + /// + /// Send the current Config in the response to this message. + var getModuleConfigResponse: ModuleConfig { + get { + if case .getModuleConfigResponse(let v)? = payloadVariant {return v} + return ModuleConfig() + } + set {payloadVariant = .getModuleConfigResponse(newValue)} + } + + /// + /// Send all channels in the response to this message + var getAllChannelRequest: Bool { + get { + if case .getAllChannelRequest(let v)? = payloadVariant {return v} + return false + } + set {payloadVariant = .getAllChannelRequest(newValue)} + } + + /// + /// Get the Canned Message Module messages in the response to this message. + var getCannedMessageModuleMessagesRequest: Bool { + get { + if case .getCannedMessageModuleMessagesRequest(let v)? = payloadVariant {return v} + return false + } + set {payloadVariant = .getCannedMessageModuleMessagesRequest(newValue)} + } + + /// + /// Get the Canned Message Module messages in the response to this message. + var getCannedMessageModuleMessagesResponse: String { + get { + if case .getCannedMessageModuleMessagesResponse(let v)? = payloadVariant {return v} + return String() + } + set {payloadVariant = .getCannedMessageModuleMessagesResponse(newValue)} + } + + /// + /// Request the node to send device metadata (firmware, protobuf version, etc) + var getDeviceMetadataRequest: UInt32 { + get { + if case .getDeviceMetadataRequest(let v)? = payloadVariant {return v} + return 0 + } + set {payloadVariant = .getDeviceMetadataRequest(newValue)} + } + + /// + /// Device metadata response + var getDeviceMetadataResponse: DeviceMetadata { + get { + if case .getDeviceMetadataResponse(let v)? = payloadVariant {return v} + return DeviceMetadata() + } + set {payloadVariant = .getDeviceMetadataResponse(newValue)} + } /// /// Set the owner for this node var setOwner: User { get { - if case .setOwner(let v)? = variant {return v} + if case .setOwner(let v)? = payloadVariant {return v} return User() } - set {variant = .setOwner(newValue)} + set {payloadVariant = .setOwner(newValue)} } /// @@ -51,141 +182,60 @@ struct AdminMessage { /// If the client sets a particular channel to be primary, the previous channel will be set to SECONDARY automatically. var setChannel: Channel { get { - if case .setChannel(let v)? = variant {return v} + if case .setChannel(let v)? = payloadVariant {return v} return Channel() } - set {variant = .setChannel(newValue)} - } - - /// - /// 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) - var getChannelRequest: UInt32 { - get { - if case .getChannelRequest(let v)? = variant {return v} - return 0 - } - set {variant = .getChannelRequest(newValue)} - } - - /// - /// TODO: REPLACE - var getChannelResponse: Channel { - get { - if case .getChannelResponse(let v)? = variant {return v} - return Channel() - } - set {variant = .getChannelResponse(newValue)} - } - - /// - /// Send the current owner data in the response to this message. - var getOwnerRequest: Bool { - get { - if case .getOwnerRequest(let v)? = variant {return v} - return false - } - set {variant = .getOwnerRequest(newValue)} - } - - /// - /// TODO: REPLACE - var getOwnerResponse: User { - get { - if case .getOwnerResponse(let v)? = variant {return v} - return User() - } - set {variant = .getOwnerResponse(newValue)} - } - - /// - /// Ask for the following config data to be sent - var getConfigRequest: AdminMessage.ConfigType { - get { - if case .getConfigRequest(let v)? = variant {return v} - return .deviceConfig - } - set {variant = .getConfigRequest(newValue)} - } - - /// - /// Send the current Config in the response to this message. - var getConfigResponse: Config { - get { - if case .getConfigResponse(let v)? = variant {return v} - return Config() - } - set {variant = .getConfigResponse(newValue)} + set {payloadVariant = .setChannel(newValue)} } /// /// Set the current Config var setConfig: Config { get { - if case .setConfig(let v)? = variant {return v} + if case .setConfig(let v)? = payloadVariant {return v} return Config() } - set {variant = .setConfig(newValue)} - } - - /// - /// Sent immediatly after a config change has been sent to ensure comms, if this is not recieved, the config will be reverted after 10 mins - var confirmSetConfig: Bool { - get { - if case .confirmSetConfig(let v)? = variant {return v} - return false - } - set {variant = .confirmSetConfig(newValue)} - } - - /// - /// Ask for the following config data to be sent - var getModuleConfigRequest: AdminMessage.ModuleConfigType { - get { - if case .getModuleConfigRequest(let v)? = variant {return v} - return .mqttConfig - } - set {variant = .getModuleConfigRequest(newValue)} - } - - /// - /// Send the current Config in the response to this message. - var getModuleConfigResponse: ModuleConfig { - get { - if case .getModuleConfigResponse(let v)? = variant {return v} - return ModuleConfig() - } - set {variant = .getModuleConfigResponse(newValue)} + set {payloadVariant = .setConfig(newValue)} } /// /// Set the current Config var setModuleConfig: ModuleConfig { get { - if case .setModuleConfig(let v)? = variant {return v} + if case .setModuleConfig(let v)? = payloadVariant {return v} return ModuleConfig() } - set {variant = .setModuleConfig(newValue)} + set {payloadVariant = .setModuleConfig(newValue)} + } + + /// + /// Set the Canned Message Module messages text. + var setCannedMessageModuleMessages: String { + get { + if case .setCannedMessageModuleMessages(let v)? = payloadVariant {return v} + return String() + } + set {payloadVariant = .setCannedMessageModuleMessages(newValue)} + } + + /// + /// Sent immediatly after a config change has been sent to ensure comms, if this is not recieved, the config will be reverted after 10 mins + var confirmSetConfig: Bool { + get { + if case .confirmSetConfig(let v)? = payloadVariant {return v} + return false + } + set {payloadVariant = .confirmSetConfig(newValue)} } /// /// Sent immediatly after a config change has been sent to ensure comms, if this is not recieved, the config will be reverted after 10 mins var confirmSetModuleConfig: Bool { get { - if case .confirmSetModuleConfig(let v)? = variant {return v} + if case .confirmSetModuleConfig(let v)? = payloadVariant {return v} return false } - set {variant = .confirmSetModuleConfig(newValue)} - } - - /// - /// Send all channels in the response to this message - var getAllChannelRequest: Bool { - get { - if case .getAllChannelRequest(let v)? = variant {return v} - return false - } - set {variant = .getAllChannelRequest(newValue)} + set {payloadVariant = .confirmSetModuleConfig(newValue)} } /// @@ -195,20 +245,20 @@ struct AdminMessage { /// These messages are optional when changing the local node. var confirmSetChannel: Bool { get { - if case .confirmSetChannel(let v)? = variant {return v} + if case .confirmSetChannel(let v)? = payloadVariant {return v} return false } - set {variant = .confirmSetChannel(newValue)} + set {payloadVariant = .confirmSetChannel(newValue)} } /// /// TODO: REPLACE var confirmSetRadio: Bool { get { - if case .confirmSetRadio(let v)? = variant {return v} + if case .confirmSetRadio(let v)? = payloadVariant {return v} return false } - set {variant = .confirmSetRadio(newValue)} + set {payloadVariant = .confirmSetRadio(newValue)} } /// @@ -216,97 +266,47 @@ struct AdminMessage { /// If received the simulator will exit successfully. var exitSimulator: Bool { get { - if case .exitSimulator(let v)? = variant {return v} + if case .exitSimulator(let v)? = payloadVariant {return v} return false } - set {variant = .exitSimulator(newValue)} + set {payloadVariant = .exitSimulator(newValue)} } /// /// Tell the node to reboot in this many seconds (or <0 to cancel reboot) var rebootSeconds: Int32 { get { - if case .rebootSeconds(let v)? = variant {return v} + if case .rebootSeconds(let v)? = payloadVariant {return v} return 0 } - set {variant = .rebootSeconds(newValue)} - } - - /// - /// Get the Canned Message Module messages in the response to this message. - var getCannedMessageModuleMessagesRequest: Bool { - get { - if case .getCannedMessageModuleMessagesRequest(let v)? = variant {return v} - return false - } - set {variant = .getCannedMessageModuleMessagesRequest(newValue)} - } - - /// - /// Get the Canned Message Module messages in the response to this message. - var getCannedMessageModuleMessagesResponse: String { - get { - if case .getCannedMessageModuleMessagesResponse(let v)? = variant {return v} - return String() - } - set {variant = .getCannedMessageModuleMessagesResponse(newValue)} - } - - /// - /// Set the Canned Message Module messages text. - var setCannedMessageModuleMessages: String { - get { - if case .setCannedMessageModuleMessages(let v)? = variant {return v} - return String() - } - set {variant = .setCannedMessageModuleMessages(newValue)} + set {payloadVariant = .rebootSeconds(newValue)} } /// /// Tell the node to shutdown in this many seconds (or <0 to cancel shutdown) var shutdownSeconds: Int32 { get { - if case .shutdownSeconds(let v)? = variant {return v} + if case .shutdownSeconds(let v)? = payloadVariant {return v} return 0 } - set {variant = .shutdownSeconds(newValue)} + set {payloadVariant = .shutdownSeconds(newValue)} } /// - /// Request the node to send device metadata (firmware, protobuf version, etc) - var getDeviceMetadataRequest: UInt32 { + /// Tell the node to factory reset, all device settings will be returned to factory defaults. + var factoryReset: Int32 { get { - if case .getDeviceMetadataRequest(let v)? = variant {return v} + if case .factoryReset(let v)? = payloadVariant {return v} return 0 } - set {variant = .getDeviceMetadataRequest(newValue)} - } - - /// - /// Device metadata response - var getDeviceMetadataResponse: DeviceMetadata { - get { - if case .getDeviceMetadataResponse(let v)? = variant {return v} - return DeviceMetadata() - } - set {variant = .getDeviceMetadataResponse(newValue)} + set {payloadVariant = .factoryReset(newValue)} } var unknownFields = SwiftProtobuf.UnknownStorage() /// /// TODO: REPLACE - enum OneOf_Variant: Equatable { - /// - /// Set the owner for this node - case setOwner(User) - /// - /// Set channels (using the new API). - /// A special channel is the "primary channel". - /// The other records are secondary channels. - /// Note: only one channel can be marked as primary. - /// If the client sets a particular channel to be primary, the previous channel will be set to SECONDARY automatically. - case setChannel(Channel) + enum OneOf_PayloadVariant: Equatable { /// /// 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) @@ -327,27 +327,52 @@ struct AdminMessage { /// Send the current Config in the response to this message. case getConfigResponse(Config) /// - /// Set the current Config - case setConfig(Config) - /// - /// Sent immediatly after a config change has been sent to ensure comms, if this is not recieved, the config will be reverted after 10 mins - case confirmSetConfig(Bool) - /// /// Ask for the following config data to be sent case getModuleConfigRequest(AdminMessage.ModuleConfigType) /// /// Send the current Config in the response to this message. case getModuleConfigResponse(ModuleConfig) /// + /// Send all channels in the response to this message + case getAllChannelRequest(Bool) + /// + /// Get the Canned Message Module messages in the response to this message. + case getCannedMessageModuleMessagesRequest(Bool) + /// + /// Get the Canned Message Module messages in the response to this message. + case getCannedMessageModuleMessagesResponse(String) + /// + /// Request the node to send device metadata (firmware, protobuf version, etc) + case getDeviceMetadataRequest(UInt32) + /// + /// Device metadata response + case getDeviceMetadataResponse(DeviceMetadata) + /// + /// Set the owner for this node + case setOwner(User) + /// + /// Set channels (using the new API). + /// A special channel is the "primary channel". + /// The other records are secondary channels. + /// Note: only one channel can be marked as primary. + /// If the client sets a particular channel to be primary, the previous channel will be set to SECONDARY automatically. + case setChannel(Channel) + /// + /// Set the current Config + case setConfig(Config) + /// /// Set the current Config case setModuleConfig(ModuleConfig) /// + /// Set the Canned Message Module messages text. + case setCannedMessageModuleMessages(String) + /// + /// Sent immediatly after a config change has been sent to ensure comms, if this is not recieved, the config will be reverted after 10 mins + case confirmSetConfig(Bool) + /// /// Sent immediatly after a config change has been sent to ensure comms, if this is not recieved, the config will be reverted after 10 mins case confirmSetModuleConfig(Bool) /// - /// Send all channels in the response to this message - case getAllChannelRequest(Bool) - /// /// Setting channels/radio config remotely carries the risk that you might send an invalid config and the radio never talks to your mesh again. /// Therefore if setting either of these properties remotely, you must send a confirm_xxx message within 10 minutes. /// If you fail to do so, the radio will assume loss of comms and revert your changes. @@ -364,38 +389,18 @@ struct AdminMessage { /// Tell the node to reboot in this many seconds (or <0 to cancel reboot) case rebootSeconds(Int32) /// - /// Get the Canned Message Module messages in the response to this message. - case getCannedMessageModuleMessagesRequest(Bool) - /// - /// Get the Canned Message Module messages in the response to this message. - case getCannedMessageModuleMessagesResponse(String) - /// - /// Set the Canned Message Module messages text. - case setCannedMessageModuleMessages(String) - /// /// Tell the node to shutdown in this many seconds (or <0 to cancel shutdown) case shutdownSeconds(Int32) /// - /// Request the node to send device metadata (firmware, protobuf version, etc) - case getDeviceMetadataRequest(UInt32) - /// - /// Device metadata response - case getDeviceMetadataResponse(DeviceMetadata) + /// Tell the node to factory reset, all device settings will be returned to factory defaults. + case factoryReset(Int32) #if !swift(>=4.1) - static func ==(lhs: AdminMessage.OneOf_Variant, rhs: AdminMessage.OneOf_Variant) -> Bool { + 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 (.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 (.getChannelRequest, .getChannelRequest): return { guard case .getChannelRequest(let l) = lhs, case .getChannelRequest(let r) = rhs else { preconditionFailure() } return l == r @@ -420,14 +425,6 @@ struct AdminMessage { guard case .getConfigResponse(let l) = lhs, case .getConfigResponse(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 (.confirmSetConfig, .confirmSetConfig): return { - guard case .confirmSetConfig(let l) = lhs, case .confirmSetConfig(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 @@ -436,16 +433,52 @@ struct AdminMessage { guard case .getModuleConfigResponse(let l) = lhs, case .getModuleConfigResponse(let r) = rhs else { preconditionFailure() } return l == r }() + case (.getAllChannelRequest, .getAllChannelRequest): return { + guard case .getAllChannelRequest(let l) = lhs, case .getAllChannelRequest(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 (.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 (.confirmSetModuleConfig, .confirmSetModuleConfig): return { - guard case .confirmSetModuleConfig(let l) = lhs, case .confirmSetModuleConfig(let r) = rhs else { preconditionFailure() } + case (.setCannedMessageModuleMessages, .setCannedMessageModuleMessages): return { + guard case .setCannedMessageModuleMessages(let l) = lhs, case .setCannedMessageModuleMessages(let r) = rhs else { preconditionFailure() } return l == r }() - case (.getAllChannelRequest, .getAllChannelRequest): return { - guard case .getAllChannelRequest(let l) = lhs, case .getAllChannelRequest(let r) = rhs else { preconditionFailure() } + case (.confirmSetConfig, .confirmSetConfig): return { + guard case .confirmSetConfig(let l) = lhs, case .confirmSetConfig(let r) = rhs else { preconditionFailure() } + return l == r + }() + case (.confirmSetModuleConfig, .confirmSetModuleConfig): return { + guard case .confirmSetModuleConfig(let l) = lhs, case .confirmSetModuleConfig(let r) = rhs else { preconditionFailure() } return l == r }() case (.confirmSetChannel, .confirmSetChannel): return { @@ -464,28 +497,12 @@ struct AdminMessage { guard case .rebootSeconds(let l) = lhs, case .rebootSeconds(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 (.setCannedMessageModuleMessages, .setCannedMessageModuleMessages): return { - guard case .setCannedMessageModuleMessages(let l) = lhs, case .setCannedMessageModuleMessages(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 (.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() } + case (.factoryReset, .factoryReset): return { + guard case .factoryReset(let l) = lhs, case .factoryReset(let r) = rhs else { preconditionFailure() } return l == r }() default: return false @@ -513,7 +530,7 @@ struct AdminMessage { /// /// TODO: REPLACE - case wifiConfig // = 3 + case networkConfig // = 3 /// /// TODO: REPLACE @@ -537,7 +554,7 @@ struct AdminMessage { case 0: self = .deviceConfig case 1: self = .positionConfig case 2: self = .powerConfig - case 3: self = .wifiConfig + case 3: self = .networkConfig case 4: self = .displayConfig case 5: self = .loraConfig case 6: self = .bluetoothConfig @@ -550,7 +567,7 @@ struct AdminMessage { case .deviceConfig: return 0 case .positionConfig: return 1 case .powerConfig: return 2 - case .wifiConfig: return 3 + case .networkConfig: return 3 case .displayConfig: return 4 case .loraConfig: return 5 case .bluetoothConfig: return 6 @@ -637,7 +654,7 @@ extension AdminMessage.ConfigType: CaseIterable { .deviceConfig, .positionConfig, .powerConfig, - .wifiConfig, + .networkConfig, .displayConfig, .loraConfig, .bluetoothConfig, @@ -661,7 +678,7 @@ extension AdminMessage.ModuleConfigType: CaseIterable { #if swift(>=5.5) && canImport(_Concurrency) extension AdminMessage: @unchecked Sendable {} -extension AdminMessage.OneOf_Variant: @unchecked Sendable {} +extension AdminMessage.OneOf_PayloadVariant: @unchecked Sendable {} extension AdminMessage.ConfigType: @unchecked Sendable {} extension AdminMessage.ModuleConfigType: @unchecked Sendable {} #endif // swift(>=5.5) && canImport(_Concurrency) @@ -671,31 +688,32 @@ extension AdminMessage.ModuleConfigType: @unchecked Sendable {} extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = "AdminMessage" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .standard(proto: "set_owner"), - 3: .standard(proto: "set_channel"), - 6: .standard(proto: "get_channel_request"), - 7: .standard(proto: "get_channel_response"), - 8: .standard(proto: "get_owner_request"), - 9: .standard(proto: "get_owner_response"), - 10: .standard(proto: "get_config_request"), - 11: .standard(proto: "get_config_response"), - 12: .standard(proto: "set_config"), - 13: .standard(proto: "confirm_set_config"), - 14: .standard(proto: "get_module_config_request"), - 15: .standard(proto: "get_module_config_response"), - 16: .standard(proto: "set_module_config"), - 17: .standard(proto: "confirm_set_module_config"), - 18: .standard(proto: "get_all_channel_request"), - 32: .standard(proto: "confirm_set_channel"), - 33: .standard(proto: "confirm_set_radio"), - 34: .standard(proto: "exit_simulator"), - 35: .standard(proto: "reboot_seconds"), - 36: .standard(proto: "get_canned_message_module_messages_request"), - 37: .standard(proto: "get_canned_message_module_messages_response"), - 44: .standard(proto: "set_canned_message_module_messages"), - 51: .standard(proto: "shutdown_seconds"), - 52: .standard(proto: "get_device_metadata_request"), - 53: .standard(proto: "get_device_metadata_response"), + 1: .standard(proto: "get_channel_request"), + 2: .standard(proto: "get_channel_response"), + 3: .standard(proto: "get_owner_request"), + 4: .standard(proto: "get_owner_response"), + 5: .standard(proto: "get_config_request"), + 6: .standard(proto: "get_config_response"), + 7: .standard(proto: "get_module_config_request"), + 8: .standard(proto: "get_module_config_response"), + 9: .standard(proto: "get_all_channel_request"), + 10: .standard(proto: "get_canned_message_module_messages_request"), + 11: .standard(proto: "get_canned_message_module_messages_response"), + 12: .standard(proto: "get_device_metadata_request"), + 13: .standard(proto: "get_device_metadata_response"), + 32: .standard(proto: "set_owner"), + 33: .standard(proto: "set_channel"), + 34: .standard(proto: "set_config"), + 35: .standard(proto: "set_module_config"), + 36: .standard(proto: "set_canned_message_module_messages"), + 64: .standard(proto: "confirm_set_config"), + 65: .standard(proto: "confirm_set_module_config"), + 66: .standard(proto: "confirm_set_channel"), + 67: .standard(proto: "confirm_set_radio"), + 96: .standard(proto: "exit_simulator"), + 97: .standard(proto: "reboot_seconds"), + 98: .standard(proto: "shutdown_seconds"), + 99: .standard(proto: "factory_reset"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -704,249 +722,257 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 2: try { - var v: User? - var hadOneofValue = false - if let current = self.variant { - hadOneofValue = true - if case .setOwner(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .setOwner(v) - } - }() - case 3: try { - var v: Channel? - var hadOneofValue = false - if let current = self.variant { - hadOneofValue = true - if case .setChannel(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .setChannel(v) - } - }() - case 6: try { + case 1: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getChannelRequest(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getChannelRequest(v) } }() - case 7: try { + case 2: try { var v: Channel? var hadOneofValue = false - if let current = self.variant { + if let current = self.payloadVariant { hadOneofValue = true if case .getChannelResponse(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .getChannelResponse(v) + self.payloadVariant = .getChannelResponse(v) } }() - case 8: try { + case 3: try { var v: Bool? try decoder.decodeSingularBoolField(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getOwnerRequest(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getOwnerRequest(v) } }() - case 9: try { + case 4: try { var v: User? var hadOneofValue = false - if let current = self.variant { + if let current = self.payloadVariant { hadOneofValue = true if case .getOwnerResponse(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .getOwnerResponse(v) + self.payloadVariant = .getOwnerResponse(v) } }() - case 10: try { + case 5: try { var v: AdminMessage.ConfigType? try decoder.decodeSingularEnumField(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getConfigRequest(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getConfigRequest(v) } }() - case 11: try { + case 6: try { var v: Config? var hadOneofValue = false - if let current = self.variant { + if let current = self.payloadVariant { hadOneofValue = true if case .getConfigResponse(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .getConfigResponse(v) + self.payloadVariant = .getConfigResponse(v) } }() - case 12: try { - var v: Config? - var hadOneofValue = false - if let current = self.variant { - hadOneofValue = true - if case .setConfig(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .setConfig(v) - } - }() - case 13: try { - var v: Bool? - try decoder.decodeSingularBoolField(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .confirmSetConfig(v) - } - }() - case 14: try { + case 7: try { var v: AdminMessage.ModuleConfigType? try decoder.decodeSingularEnumField(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getModuleConfigRequest(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getModuleConfigRequest(v) } }() - case 15: try { + case 8: try { var v: ModuleConfig? var hadOneofValue = false - if let current = self.variant { + if let current = self.payloadVariant { hadOneofValue = true if case .getModuleConfigResponse(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .getModuleConfigResponse(v) + self.payloadVariant = .getModuleConfigResponse(v) } }() - case 16: try { - var v: ModuleConfig? - var hadOneofValue = false - if let current = self.variant { - hadOneofValue = true - if case .setModuleConfig(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .setModuleConfig(v) - } - }() - case 17: try { + case 9: try { var v: Bool? try decoder.decodeSingularBoolField(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .confirmSetModuleConfig(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getAllChannelRequest(v) } }() - case 18: try { + case 10: try { var v: Bool? try decoder.decodeSingularBoolField(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getAllChannelRequest(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getCannedMessageModuleMessagesRequest(v) } }() - case 32: try { - var v: Bool? - try decoder.decodeSingularBoolField(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .confirmSetChannel(v) - } - }() - case 33: try { - var v: Bool? - try decoder.decodeSingularBoolField(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .confirmSetRadio(v) - } - }() - case 34: try { - var v: Bool? - try decoder.decodeSingularBoolField(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .exitSimulator(v) - } - }() - case 35: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .rebootSeconds(v) - } - }() - case 36: try { - var v: Bool? - try decoder.decodeSingularBoolField(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getCannedMessageModuleMessagesRequest(v) - } - }() - case 37: try { + case 11: try { var v: String? try decoder.decodeSingularStringField(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getCannedMessageModuleMessagesResponse(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getCannedMessageModuleMessagesResponse(v) } }() - case 44: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .setCannedMessageModuleMessages(v) - } - }() - case 51: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .shutdownSeconds(v) - } - }() - case 52: try { + case 12: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) if let v = v { - if self.variant != nil {try decoder.handleConflictingOneOf()} - self.variant = .getDeviceMetadataRequest(v) + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .getDeviceMetadataRequest(v) } }() - case 53: try { + case 13: try { var v: DeviceMetadata? var hadOneofValue = false - if let current = self.variant { + if let current = self.payloadVariant { hadOneofValue = true if case .getDeviceMetadataResponse(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} - self.variant = .getDeviceMetadataResponse(v) + self.payloadVariant = .getDeviceMetadataResponse(v) + } + }() + case 32: try { + var v: User? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .setOwner(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .setOwner(v) + } + }() + case 33: try { + var v: Channel? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .setChannel(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .setChannel(v) + } + }() + case 34: try { + var v: Config? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .setConfig(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .setConfig(v) + } + }() + case 35: try { + var v: ModuleConfig? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .setModuleConfig(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .setModuleConfig(v) + } + }() + case 36: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .setCannedMessageModuleMessages(v) + } + }() + case 64: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .confirmSetConfig(v) + } + }() + case 65: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .confirmSetModuleConfig(v) + } + }() + case 66: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .confirmSetChannel(v) + } + }() + case 67: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .confirmSetRadio(v) + } + }() + case 96: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .exitSimulator(v) + } + }() + case 97: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .rebootSeconds(v) + } + }() + case 98: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .shutdownSeconds(v) + } + }() + case 99: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .factoryReset(v) } }() default: break @@ -959,106 +985,110 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat // 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 - switch self.variant { - case .setOwner?: try { - guard case .setOwner(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - }() - case .setChannel?: try { - guard case .setChannel(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - }() + switch self.payloadVariant { case .getChannelRequest?: try { - guard case .getChannelRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 6) + guard case .getChannelRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) }() case .getChannelResponse?: try { - guard case .getChannelResponse(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + guard case .getChannelResponse(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) }() case .getOwnerRequest?: try { - guard case .getOwnerRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 8) + guard case .getOwnerRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) }() case .getOwnerResponse?: try { - guard case .getOwnerResponse(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + guard case .getOwnerResponse(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) }() case .getConfigRequest?: try { - guard case .getConfigRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 10) + guard case .getConfigRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) }() case .getConfigResponse?: try { - guard case .getConfigResponse(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - }() - case .setConfig?: try { - guard case .setConfig(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 12) - }() - case .confirmSetConfig?: try { - guard case .confirmSetConfig(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + guard case .getConfigResponse(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) }() case .getModuleConfigRequest?: try { - guard case .getModuleConfigRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 14) + guard case .getModuleConfigRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) }() case .getModuleConfigResponse?: try { - guard case .getModuleConfigResponse(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 15) - }() - case .setModuleConfig?: try { - guard case .setModuleConfig(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 16) - }() - case .confirmSetModuleConfig?: try { - guard case .confirmSetModuleConfig(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 17) + guard case .getModuleConfigResponse(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) }() case .getAllChannelRequest?: try { - guard case .getAllChannelRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 18) - }() - case .confirmSetChannel?: try { - guard case .confirmSetChannel(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 32) - }() - case .confirmSetRadio?: try { - guard case .confirmSetRadio(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 33) - }() - case .exitSimulator?: try { - guard case .exitSimulator(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 34) - }() - case .rebootSeconds?: try { - guard case .rebootSeconds(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 35) + guard case .getAllChannelRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 9) }() case .getCannedMessageModuleMessagesRequest?: try { - guard case .getCannedMessageModuleMessagesRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 36) + guard case .getCannedMessageModuleMessagesRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 10) }() case .getCannedMessageModuleMessagesResponse?: try { - guard case .getCannedMessageModuleMessagesResponse(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 37) - }() - case .setCannedMessageModuleMessages?: try { - guard case .setCannedMessageModuleMessages(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 44) - }() - case .shutdownSeconds?: try { - guard case .shutdownSeconds(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 51) + guard case .getCannedMessageModuleMessagesResponse(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 11) }() case .getDeviceMetadataRequest?: try { - guard case .getDeviceMetadataRequest(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 52) + guard case .getDeviceMetadataRequest(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 12) }() case .getDeviceMetadataResponse?: try { - guard case .getDeviceMetadataResponse(let v)? = self.variant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 53) + guard case .getDeviceMetadataResponse(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 13) + }() + case .setOwner?: try { + guard case .setOwner(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 32) + }() + case .setChannel?: try { + guard case .setChannel(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 33) + }() + case .setConfig?: try { + guard case .setConfig(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + }() + case .setModuleConfig?: try { + guard case .setModuleConfig(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 35) + }() + case .setCannedMessageModuleMessages?: try { + guard case .setCannedMessageModuleMessages(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 36) + }() + case .confirmSetConfig?: try { + guard case .confirmSetConfig(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 64) + }() + case .confirmSetModuleConfig?: try { + guard case .confirmSetModuleConfig(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 65) + }() + case .confirmSetChannel?: try { + guard case .confirmSetChannel(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 66) + }() + case .confirmSetRadio?: try { + guard case .confirmSetRadio(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 67) + }() + case .exitSimulator?: try { + guard case .exitSimulator(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 96) + }() + case .rebootSeconds?: try { + guard case .rebootSeconds(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 97) + }() + case .shutdownSeconds?: try { + guard case .shutdownSeconds(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 98) + }() + case .factoryReset?: try { + guard case .factoryReset(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) }() case nil: break } @@ -1066,7 +1096,7 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat } static func ==(lhs: AdminMessage, rhs: AdminMessage) -> Bool { - if lhs.variant != rhs.variant {return false} + if lhs.payloadVariant != rhs.payloadVariant {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -1077,7 +1107,7 @@ extension AdminMessage.ConfigType: SwiftProtobuf._ProtoNameProviding { 0: .same(proto: "DEVICE_CONFIG"), 1: .same(proto: "POSITION_CONFIG"), 2: .same(proto: "POWER_CONFIG"), - 3: .same(proto: "WIFI_CONFIG"), + 3: .same(proto: "NETWORK_CONFIG"), 4: .same(proto: "DISPLAY_CONFIG"), 5: .same(proto: "LORA_CONFIG"), 6: .same(proto: "BLUETOOTH_CONFIG"), diff --git a/Meshtastic/Protobufs/localonly.pb.swift b/Meshtastic/Protobufs/localonly.pb.swift index b9322fb0..8ad6ccf6 100644 --- a/Meshtastic/Protobufs/localonly.pb.swift +++ b/Meshtastic/Protobufs/localonly.pb.swift @@ -60,14 +60,14 @@ struct LocalConfig { /// /// The part of the config that is specific to the Wifi Settings - var wifi: Config.WiFiConfig { - get {return _storage._wifi ?? Config.WiFiConfig()} - set {_uniqueStorage()._wifi = newValue} + var network: Config.NetworkConfig { + get {return _storage._network ?? Config.NetworkConfig()} + set {_uniqueStorage()._network = newValue} } - /// Returns true if `wifi` has been explicitly set. - var hasWifi: Bool {return _storage._wifi != nil} - /// Clears the value of `wifi`. Subsequent reads from it will return its default value. - mutating func clearWifi() {_uniqueStorage()._wifi = nil} + /// Returns true if `network` has been explicitly set. + var hasNetwork: Bool {return _storage._network != nil} + /// Clears the value of `network`. Subsequent reads from it will return its default value. + mutating func clearNetwork() {_uniqueStorage()._network = nil} /// /// The part of the config that is specific to the Display @@ -229,7 +229,7 @@ extension LocalConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati 1: .same(proto: "device"), 2: .same(proto: "position"), 3: .same(proto: "power"), - 4: .same(proto: "wifi"), + 4: .same(proto: "network"), 5: .same(proto: "display"), 6: .same(proto: "lora"), 7: .same(proto: "bluetooth"), @@ -240,7 +240,7 @@ extension LocalConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati var _device: Config.DeviceConfig? = nil var _position: Config.PositionConfig? = nil var _power: Config.PowerConfig? = nil - var _wifi: Config.NetworkConfig? = nil + var _network: Config.NetworkConfig? = nil var _display: Config.DisplayConfig? = nil var _lora: Config.LoRaConfig? = nil var _bluetooth: Config.BluetoothConfig? = nil @@ -254,7 +254,7 @@ extension LocalConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati _device = source._device _position = source._position _power = source._power - _wifi = source._wifi + _network = source._network _display = source._display _lora = source._lora _bluetooth = source._bluetooth @@ -280,7 +280,7 @@ extension LocalConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati case 1: try { try decoder.decodeSingularMessageField(value: &_storage._device) }() case 2: try { try decoder.decodeSingularMessageField(value: &_storage._position) }() case 3: try { try decoder.decodeSingularMessageField(value: &_storage._power) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._wifi) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._network) }() case 5: try { try decoder.decodeSingularMessageField(value: &_storage._display) }() case 6: try { try decoder.decodeSingularMessageField(value: &_storage._lora) }() case 7: try { try decoder.decodeSingularMessageField(value: &_storage._bluetooth) }() @@ -306,7 +306,7 @@ extension LocalConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati try { if let v = _storage._power { try visitor.visitSingularMessageField(value: v, fieldNumber: 3) } }() - try { if let v = _storage._wifi { + try { if let v = _storage._network { try visitor.visitSingularMessageField(value: v, fieldNumber: 4) } }() try { if let v = _storage._display { @@ -333,7 +333,7 @@ extension LocalConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati if _storage._device != rhs_storage._device {return false} if _storage._position != rhs_storage._position {return false} if _storage._power != rhs_storage._power {return false} - if _storage._wifi != rhs_storage._wifi {return false} + if _storage._network != rhs_storage._network {return false} if _storage._display != rhs_storage._display {return false} if _storage._lora != rhs_storage._lora {return false} if _storage._bluetooth != rhs_storage._bluetooth {return false} diff --git a/Meshtastic/Protobufs/mesh.pb.swift b/Meshtastic/Protobufs/mesh.pb.swift index b5a68d2d..09e9fa56 100644 --- a/Meshtastic/Protobufs/mesh.pb.swift +++ b/Meshtastic/Protobufs/mesh.pb.swift @@ -55,7 +55,7 @@ enum HardwareModel: SwiftProtobuf.Enum { /// /// TODO: REPLACE - case tbeam0P7 // = 6 + case tbeamV0P7 // = 6 /// /// TODO: REPLACE @@ -78,6 +78,22 @@ enum HardwareModel: SwiftProtobuf.Enum { /// Ancient heltec WiFi_Lora_32 board case heltecV1 // = 11 + /// + /// New T-BEAM with ESP32-S3 CPU + case lilygoTbeamS3Core // = 12 + + /// + /// RAK WisBlock ESP32 core: https://docs.rakwireless.com/Product-Categories/WisBlock/RAK11200/Overview/ + case rak11200 // = 13 + + /// + /// B&Q Consulting Nano Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:nano + case nanoG1 // = 14 + + /// + /// B&Q Consulting Station Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:station + case stationG1 // = 25 + /// /// Less common/prototype boards listed here (needs one more byte over the air) case loraRelayV1 // = 32 @@ -110,29 +126,17 @@ enum HardwareModel: SwiftProtobuf.Enum { /// Custom DIY device based on @NanoVHF schematics: https://github.com/NanoVHF/Meshtastic-DIY/tree/main/Schematics case diyV1 // = 39 - /// - /// RAK WisBlock ESP32 core: https://docs.rakwireless.com/Product-Categories/WisBlock/RAK11200/Overview/ - case rak11200 // = 40 - - /// - /// B&Q Consulting Nano Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:nano - case nanoG1 // = 41 - /// /// nRF52840 Dongle : https://www.nordicsemi.com/Products/Development-hardware/nrf52840-dongle/ - case nrf52840Pca10059 // = 42 + case nrf52840Pca10059 // = 40 /// /// Custom Disaster Radio esp32 v3 device https://github.com/sudomesh/disaster-radio/tree/master/hardware/board_esp32_v3 - case drDev // = 43 + case drDev // = 41 /// /// M5 esp32 based MCU modules with enclosure, TFT and LORA Shields. All Variants (Basic, Core, Fire, Core2, Paper) https://m5stack.com/ - case m5Stack // = 44 - - /// - /// B&Q Consulting Station Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:station - case stationG1 // = 45 + case m5Stack // = 42 /// /// 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. @@ -151,12 +155,16 @@ enum HardwareModel: SwiftProtobuf.Enum { case 3: self = .tloraV211P6 case 4: self = .tbeam case 5: self = .heltecV20 - case 6: self = .tbeam0P7 + case 6: self = .tbeamV0P7 case 7: self = .tEcho case 8: self = .tloraV11P3 case 9: self = .rak4631 case 10: self = .heltecV21 case 11: self = .heltecV1 + case 12: self = .lilygoTbeamS3Core + case 13: self = .rak11200 + case 14: self = .nanoG1 + case 25: self = .stationG1 case 32: self = .loraRelayV1 case 33: self = .nrf52840Dk case 34: self = .ppr @@ -165,12 +173,9 @@ enum HardwareModel: SwiftProtobuf.Enum { case 37: self = .portduino case 38: self = .androidSim case 39: self = .diyV1 - case 40: self = .rak11200 - case 41: self = .nanoG1 - case 42: self = .nrf52840Pca10059 - case 43: self = .drDev - case 44: self = .m5Stack - case 45: self = .stationG1 + case 40: self = .nrf52840Pca10059 + case 41: self = .drDev + case 42: self = .m5Stack case 255: self = .privateHw default: self = .UNRECOGNIZED(rawValue) } @@ -184,12 +189,16 @@ enum HardwareModel: SwiftProtobuf.Enum { case .tloraV211P6: return 3 case .tbeam: return 4 case .heltecV20: return 5 - case .tbeam0P7: return 6 + case .tbeamV0P7: return 6 case .tEcho: return 7 case .tloraV11P3: return 8 case .rak4631: return 9 case .heltecV21: return 10 case .heltecV1: return 11 + case .lilygoTbeamS3Core: return 12 + case .rak11200: return 13 + case .nanoG1: return 14 + case .stationG1: return 25 case .loraRelayV1: return 32 case .nrf52840Dk: return 33 case .ppr: return 34 @@ -198,12 +207,9 @@ enum HardwareModel: SwiftProtobuf.Enum { case .portduino: return 37 case .androidSim: return 38 case .diyV1: return 39 - case .rak11200: return 40 - case .nanoG1: return 41 - case .nrf52840Pca10059: return 42 - case .drDev: return 43 - case .m5Stack: return 44 - case .stationG1: return 45 + case .nrf52840Pca10059: return 40 + case .drDev: return 41 + case .m5Stack: return 42 case .privateHw: return 255 case .UNRECOGNIZED(let i): return i } @@ -222,12 +228,16 @@ extension HardwareModel: CaseIterable { .tloraV211P6, .tbeam, .heltecV20, - .tbeam0P7, + .tbeamV0P7, .tEcho, .tloraV11P3, .rak4631, .heltecV21, .heltecV1, + .lilygoTbeamS3Core, + .rak11200, + .nanoG1, + .stationG1, .loraRelayV1, .nrf52840Dk, .ppr, @@ -236,12 +246,9 @@ extension HardwareModel: CaseIterable { .portduino, .androidSim, .diyV1, - .rak11200, - .nanoG1, .nrf52840Pca10059, .drDev, .m5Stack, - .stationG1, .privateHw, ] } @@ -256,7 +263,7 @@ enum Constants: SwiftProtobuf.Enum { /// /// First enum must be zero, and we are just using this enum to /// pass int constants between two very different environments - case unused // = 0 + case zero // = 0 /// /// From mesh.options @@ -266,12 +273,12 @@ enum Constants: SwiftProtobuf.Enum { case UNRECOGNIZED(Int) init() { - self = .unused + self = .zero } init?(rawValue: Int) { switch rawValue { - case 0: self = .unused + case 0: self = .zero case 237: self = .dataPayloadLen default: self = .UNRECOGNIZED(rawValue) } @@ -279,7 +286,7 @@ enum Constants: SwiftProtobuf.Enum { var rawValue: Int { switch self { - case .unused: return 0 + case .zero: return 0 case .dataPayloadLen: return 237 case .UNRECOGNIZED(let i): return i } @@ -292,7 +299,7 @@ enum Constants: SwiftProtobuf.Enum { extension Constants: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Constants] = [ - .unused, + .zero, .dataPayloadLen, ] } @@ -329,7 +336,7 @@ enum CriticalErrorCode: SwiftProtobuf.Enum { /// /// We failed while configuring a UBlox GPS - case ubloxInitFailed // = 5 + case ubloxUnitFailed // = 5 /// /// This board was expected to have a power management chip and it is missing or broken @@ -369,7 +376,7 @@ enum CriticalErrorCode: SwiftProtobuf.Enum { case 2: self = .sleepEnterWait case 3: self = .noRadio case 4: self = .unspecified - case 5: self = .ubloxInitFailed + case 5: self = .ubloxUnitFailed case 6: self = .noAxp192 case 7: self = .invalidRadioSetting case 8: self = .transmitFailed @@ -387,7 +394,7 @@ enum CriticalErrorCode: SwiftProtobuf.Enum { case .sleepEnterWait: return 2 case .noRadio: return 3 case .unspecified: return 4 - case .ubloxInitFailed: return 5 + case .ubloxUnitFailed: return 5 case .noAxp192: return 6 case .invalidRadioSetting: return 7 case .transmitFailed: return 8 @@ -410,7 +417,7 @@ extension CriticalErrorCode: CaseIterable { .sleepEnterWait, .noRadio, .unspecified, - .ubloxInitFailed, + .ubloxUnitFailed, .noAxp192, .invalidRadioSetting, .transmitFailed, @@ -478,16 +485,16 @@ struct Position { /// /// Positional timestamp (actual timestamp of GPS solution) in integer epoch seconds - var posTimestamp: UInt32 { - get {return _storage._posTimestamp} - set {_uniqueStorage()._posTimestamp = newValue} + var timestamp: UInt32 { + get {return _storage._timestamp} + set {_uniqueStorage()._timestamp = newValue} } /// /// Pos. timestamp milliseconds adjustment (rarely available or required) - var posTimeMillis: Int32 { - get {return _storage._posTimeMillis} - set {_uniqueStorage()._posTimeMillis = newValue} + var timestampMillisAdjust: Int32 { + get {return _storage._timestampMillisAdjust} + set {_uniqueStorage()._timestampMillisAdjust = newValue} } /// @@ -499,9 +506,9 @@ struct Position { /// /// Geoidal separation in meters - var altGeoidSep: Int32 { - get {return _storage._altGeoidSep} - set {_uniqueStorage()._altGeoidSep = newValue} + var altitudeGeoidalSeperation: Int32 { + get {return _storage._altitudeGeoidalSeperation} + set {_uniqueStorage()._altitudeGeoidalSeperation = newValue} } /// @@ -590,17 +597,17 @@ struct Position { /// - if we update at fixed intervals of X seconds, use X /// - if we update at dynamic intervals (based on relative movement etc), /// but "AT LEAST every Y seconds", use Y - var posNextUpdate: UInt32 { - get {return _storage._posNextUpdate} - set {_uniqueStorage()._posNextUpdate = newValue} + var nextUpdate: UInt32 { + get {return _storage._nextUpdate} + set {_uniqueStorage()._nextUpdate = newValue} } /// /// A sequence number, incremented with each Position message to help /// detect lost updates if needed - var posSeqNumber: UInt32 { - get {return _storage._posSeqNumber} - set {_uniqueStorage()._posSeqNumber = newValue} + var seqNumber: UInt32 { + get {return _storage._seqNumber} + set {_uniqueStorage()._seqNumber = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() @@ -612,41 +619,41 @@ struct Position { /// /// TODO: REPLACE - case locsrcUnspecified // = 0 + case locUnset // = 0 /// /// TODO: REPLACE - case locsrcManualEntry // = 1 + case locManual // = 1 /// /// TODO: REPLACE - case locsrcGpsInternal // = 2 + case locInternal // = 2 /// /// TODO: REPLACE - case locsrcGpsExternal // = 3 + case locExternal // = 3 case UNRECOGNIZED(Int) init() { - self = .locsrcUnspecified + self = .locUnset } init?(rawValue: Int) { switch rawValue { - case 0: self = .locsrcUnspecified - case 1: self = .locsrcManualEntry - case 2: self = .locsrcGpsInternal - case 3: self = .locsrcGpsExternal + case 0: self = .locUnset + case 1: self = .locManual + case 2: self = .locInternal + case 3: self = .locExternal default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .locsrcUnspecified: return 0 - case .locsrcManualEntry: return 1 - case .locsrcGpsInternal: return 2 - case .locsrcGpsExternal: return 3 + case .locUnset: return 0 + case .locManual: return 1 + case .locInternal: return 2 + case .locExternal: return 3 case .UNRECOGNIZED(let i): return i } } @@ -661,47 +668,47 @@ struct Position { /// /// TODO: REPLACE - case altsrcUnspecified // = 0 + case altUnset // = 0 /// /// TODO: REPLACE - case altsrcManualEntry // = 1 + case altManual // = 1 /// /// TODO: REPLACE - case altsrcGpsInternal // = 2 + case altInternal // = 2 /// /// TODO: REPLACE - case altsrcGpsExternal // = 3 + case altExternal // = 3 /// /// TODO: REPLACE - case altsrcBarometric // = 4 + case altBarometric // = 4 case UNRECOGNIZED(Int) init() { - self = .altsrcUnspecified + self = .altUnset } init?(rawValue: Int) { switch rawValue { - case 0: self = .altsrcUnspecified - case 1: self = .altsrcManualEntry - case 2: self = .altsrcGpsInternal - case 3: self = .altsrcGpsExternal - case 4: self = .altsrcBarometric + case 0: self = .altUnset + case 1: self = .altManual + case 2: self = .altInternal + case 3: self = .altExternal + case 4: self = .altBarometric default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .altsrcUnspecified: return 0 - case .altsrcManualEntry: return 1 - case .altsrcGpsInternal: return 2 - case .altsrcGpsExternal: return 3 - case .altsrcBarometric: return 4 + case .altUnset: return 0 + case .altManual: return 1 + case .altInternal: return 2 + case .altExternal: return 3 + case .altBarometric: return 4 case .UNRECOGNIZED(let i): return i } } @@ -718,21 +725,21 @@ struct Position { extension Position.LocSource: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Position.LocSource] = [ - .locsrcUnspecified, - .locsrcManualEntry, - .locsrcGpsInternal, - .locsrcGpsExternal, + .locUnset, + .locManual, + .locInternal, + .locExternal, ] } extension Position.AltSource: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Position.AltSource] = [ - .altsrcUnspecified, - .altsrcManualEntry, - .altsrcGpsInternal, - .altsrcGpsExternal, - .altsrcBarometric, + .altUnset, + .altManual, + .altInternal, + .altExternal, + .altBarometric, ] } @@ -1112,7 +1119,7 @@ struct Waypoint { /// /// A packet envelope sent/received over the mesh -/// only payloadVariant is sent in the payload portion of the LORA packet. +/// 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. struct MeshPacket { // SwiftProtobuf.Message conformance is added in an extension below. See the @@ -1144,7 +1151,7 @@ struct MeshPacket { /// Therefore channel_index is inherently a local concept and meaningless to send between nodes. /// Very briefly, while sending and receiving deep inside the device Router code, this field instead /// contains the 'channel hash' instead of the index. - /// This 'trick' is only used while the payloadVariant is an 'encrypted'. + /// This 'trick' is only used while the payload_variant is an 'encrypted'. var channel: UInt32 { get {return _storage._channel} set {_uniqueStorage()._channel = newValue} @@ -2132,15 +2139,19 @@ extension HardwareModel: SwiftProtobuf._ProtoNameProviding { 0: .same(proto: "UNSET"), 1: .same(proto: "TLORA_V2"), 2: .same(proto: "TLORA_V1"), - 3: .same(proto: "TLORA_V2_1_1p6"), + 3: .same(proto: "TLORA_V2_1_1P6"), 4: .same(proto: "TBEAM"), 5: .same(proto: "HELTEC_V2_0"), - 6: .same(proto: "TBEAM0p7"), + 6: .same(proto: "TBEAM_V0P7"), 7: .same(proto: "T_ECHO"), - 8: .same(proto: "TLORA_V1_1p3"), + 8: .same(proto: "TLORA_V1_1P3"), 9: .same(proto: "RAK4631"), 10: .same(proto: "HELTEC_V2_1"), 11: .same(proto: "HELTEC_V1"), + 12: .same(proto: "LILYGO_TBEAM_S3_CORE"), + 13: .same(proto: "RAK11200"), + 14: .same(proto: "NANO_G1"), + 25: .same(proto: "STATION_G1"), 32: .same(proto: "LORA_RELAY_V1"), 33: .same(proto: "NRF52840DK"), 34: .same(proto: "PPR"), @@ -2149,37 +2160,34 @@ extension HardwareModel: SwiftProtobuf._ProtoNameProviding { 37: .same(proto: "PORTDUINO"), 38: .same(proto: "ANDROID_SIM"), 39: .same(proto: "DIY_V1"), - 40: .same(proto: "RAK11200"), - 41: .same(proto: "NANO_G1"), - 42: .same(proto: "NRF52840_PCA10059"), - 43: .same(proto: "DR_DEV"), - 44: .same(proto: "M5STACK"), - 45: .same(proto: "STATION_G1"), + 40: .same(proto: "NRF52840_PCA10059"), + 41: .same(proto: "DR_DEV"), + 42: .same(proto: "M5STACK"), 255: .same(proto: "PRIVATE_HW"), ] } extension Constants: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "Unused"), + 0: .same(proto: "ZERO"), 237: .same(proto: "DATA_PAYLOAD_LEN"), ] } extension CriticalErrorCode: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "None"), - 1: .same(proto: "TxWatchdog"), - 2: .same(proto: "SleepEnterWait"), - 3: .same(proto: "NoRadio"), - 4: .same(proto: "Unspecified"), - 5: .same(proto: "UBloxInitFailed"), - 6: .same(proto: "NoAXP192"), - 7: .same(proto: "InvalidRadioSetting"), - 8: .same(proto: "TransmitFailed"), - 9: .same(proto: "Brownout"), - 10: .same(proto: "SX1262Failure"), - 11: .same(proto: "RadioSpiBug"), + 0: .same(proto: "NONE"), + 1: .same(proto: "TX_WATCHDOG"), + 2: .same(proto: "SLEEP_ENTER_WAIT"), + 3: .same(proto: "NO_RADIO"), + 4: .same(proto: "UNSPECIFIED"), + 5: .same(proto: "UBLOX_UNIT_FAILED"), + 6: .same(proto: "NO_AXP192"), + 7: .same(proto: "INVALID_RADIO_SETTING"), + 8: .same(proto: "TRANSMIT_FAILED"), + 9: .same(proto: "BROWNOUT"), + 10: .same(proto: "SX1262_FAILURE"), + 11: .same(proto: "RADIO_SPI_BUG"), ] } @@ -2189,25 +2197,25 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB 1: .standard(proto: "latitude_i"), 2: .standard(proto: "longitude_i"), 3: .same(proto: "altitude"), - 9: .same(proto: "time"), - 10: .standard(proto: "location_source"), - 11: .standard(proto: "altitude_source"), - 12: .standard(proto: "pos_timestamp"), - 13: .standard(proto: "pos_time_millis"), - 14: .standard(proto: "altitude_hae"), - 15: .standard(proto: "alt_geoid_sep"), - 16: .same(proto: "PDOP"), - 17: .same(proto: "HDOP"), - 18: .same(proto: "VDOP"), - 19: .standard(proto: "gps_accuracy"), - 20: .standard(proto: "ground_speed"), - 21: .standard(proto: "ground_track"), - 22: .standard(proto: "fix_quality"), - 23: .standard(proto: "fix_type"), - 24: .standard(proto: "sats_in_view"), - 25: .standard(proto: "sensor_id"), - 40: .standard(proto: "pos_next_update"), - 41: .standard(proto: "pos_seq_number"), + 4: .same(proto: "time"), + 5: .standard(proto: "location_source"), + 6: .standard(proto: "altitude_source"), + 7: .same(proto: "timestamp"), + 8: .standard(proto: "timestamp_millis_adjust"), + 9: .standard(proto: "altitude_hae"), + 10: .standard(proto: "altitude_geoidal_seperation"), + 11: .same(proto: "PDOP"), + 12: .same(proto: "HDOP"), + 13: .same(proto: "VDOP"), + 14: .standard(proto: "gps_accuracy"), + 15: .standard(proto: "ground_speed"), + 16: .standard(proto: "ground_track"), + 17: .standard(proto: "fix_quality"), + 18: .standard(proto: "fix_type"), + 19: .standard(proto: "sats_in_view"), + 20: .standard(proto: "sensor_id"), + 21: .standard(proto: "next_update"), + 22: .standard(proto: "seq_number"), ] fileprivate class _StorageClass { @@ -2215,12 +2223,12 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB var _longitudeI: Int32 = 0 var _altitude: Int32 = 0 var _time: UInt32 = 0 - var _locationSource: Position.LocSource = .locsrcUnspecified - var _altitudeSource: Position.AltSource = .altsrcUnspecified - var _posTimestamp: UInt32 = 0 - var _posTimeMillis: Int32 = 0 + var _locationSource: Position.LocSource = .locUnset + var _altitudeSource: Position.AltSource = .altUnset + var _timestamp: UInt32 = 0 + var _timestampMillisAdjust: Int32 = 0 var _altitudeHae: Int32 = 0 - var _altGeoidSep: Int32 = 0 + var _altitudeGeoidalSeperation: Int32 = 0 var _pdop: UInt32 = 0 var _hdop: UInt32 = 0 var _vdop: UInt32 = 0 @@ -2231,8 +2239,8 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB var _fixType: UInt32 = 0 var _satsInView: UInt32 = 0 var _sensorID: UInt32 = 0 - var _posNextUpdate: UInt32 = 0 - var _posSeqNumber: UInt32 = 0 + var _nextUpdate: UInt32 = 0 + var _seqNumber: UInt32 = 0 static let defaultInstance = _StorageClass() @@ -2245,10 +2253,10 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB _time = source._time _locationSource = source._locationSource _altitudeSource = source._altitudeSource - _posTimestamp = source._posTimestamp - _posTimeMillis = source._posTimeMillis + _timestamp = source._timestamp + _timestampMillisAdjust = source._timestampMillisAdjust _altitudeHae = source._altitudeHae - _altGeoidSep = source._altGeoidSep + _altitudeGeoidalSeperation = source._altitudeGeoidalSeperation _pdop = source._pdop _hdop = source._hdop _vdop = source._vdop @@ -2259,8 +2267,8 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB _fixType = source._fixType _satsInView = source._satsInView _sensorID = source._sensorID - _posNextUpdate = source._posNextUpdate - _posSeqNumber = source._posSeqNumber + _nextUpdate = source._nextUpdate + _seqNumber = source._seqNumber } } @@ -2282,25 +2290,25 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB case 1: try { try decoder.decodeSingularSFixed32Field(value: &_storage._latitudeI) }() case 2: try { try decoder.decodeSingularSFixed32Field(value: &_storage._longitudeI) }() case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._altitude) }() - case 9: try { try decoder.decodeSingularFixed32Field(value: &_storage._time) }() - case 10: try { try decoder.decodeSingularEnumField(value: &_storage._locationSource) }() - case 11: try { try decoder.decodeSingularEnumField(value: &_storage._altitudeSource) }() - case 12: try { try decoder.decodeSingularFixed32Field(value: &_storage._posTimestamp) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._posTimeMillis) }() - case 14: try { try decoder.decodeSingularSInt32Field(value: &_storage._altitudeHae) }() - case 15: try { try decoder.decodeSingularSInt32Field(value: &_storage._altGeoidSep) }() - case 16: try { try decoder.decodeSingularUInt32Field(value: &_storage._pdop) }() - case 17: try { try decoder.decodeSingularUInt32Field(value: &_storage._hdop) }() - case 18: try { try decoder.decodeSingularUInt32Field(value: &_storage._vdop) }() - case 19: try { try decoder.decodeSingularUInt32Field(value: &_storage._gpsAccuracy) }() - case 20: try { try decoder.decodeSingularUInt32Field(value: &_storage._groundSpeed) }() - case 21: try { try decoder.decodeSingularUInt32Field(value: &_storage._groundTrack) }() - case 22: try { try decoder.decodeSingularUInt32Field(value: &_storage._fixQuality) }() - case 23: try { try decoder.decodeSingularUInt32Field(value: &_storage._fixType) }() - case 24: try { try decoder.decodeSingularUInt32Field(value: &_storage._satsInView) }() - case 25: try { try decoder.decodeSingularUInt32Field(value: &_storage._sensorID) }() - case 40: try { try decoder.decodeSingularUInt32Field(value: &_storage._posNextUpdate) }() - case 41: try { try decoder.decodeSingularUInt32Field(value: &_storage._posSeqNumber) }() + case 4: try { try decoder.decodeSingularFixed32Field(value: &_storage._time) }() + case 5: try { try decoder.decodeSingularEnumField(value: &_storage._locationSource) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._altitudeSource) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._timestamp) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._timestampMillisAdjust) }() + case 9: try { try decoder.decodeSingularSInt32Field(value: &_storage._altitudeHae) }() + case 10: try { try decoder.decodeSingularSInt32Field(value: &_storage._altitudeGeoidalSeperation) }() + case 11: try { try decoder.decodeSingularUInt32Field(value: &_storage._pdop) }() + case 12: try { try decoder.decodeSingularUInt32Field(value: &_storage._hdop) }() + case 13: try { try decoder.decodeSingularUInt32Field(value: &_storage._vdop) }() + case 14: try { try decoder.decodeSingularUInt32Field(value: &_storage._gpsAccuracy) }() + case 15: try { try decoder.decodeSingularUInt32Field(value: &_storage._groundSpeed) }() + case 16: try { try decoder.decodeSingularUInt32Field(value: &_storage._groundTrack) }() + case 17: try { try decoder.decodeSingularUInt32Field(value: &_storage._fixQuality) }() + case 18: try { try decoder.decodeSingularUInt32Field(value: &_storage._fixType) }() + case 19: try { try decoder.decodeSingularUInt32Field(value: &_storage._satsInView) }() + case 20: try { try decoder.decodeSingularUInt32Field(value: &_storage._sensorID) }() + case 21: try { try decoder.decodeSingularUInt32Field(value: &_storage._nextUpdate) }() + case 22: try { try decoder.decodeSingularUInt32Field(value: &_storage._seqNumber) }() default: break } } @@ -2319,61 +2327,61 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB try visitor.visitSingularInt32Field(value: _storage._altitude, fieldNumber: 3) } if _storage._time != 0 { - try visitor.visitSingularFixed32Field(value: _storage._time, fieldNumber: 9) + try visitor.visitSingularFixed32Field(value: _storage._time, fieldNumber: 4) } - if _storage._locationSource != .locsrcUnspecified { - try visitor.visitSingularEnumField(value: _storage._locationSource, fieldNumber: 10) + if _storage._locationSource != .locUnset { + try visitor.visitSingularEnumField(value: _storage._locationSource, fieldNumber: 5) } - if _storage._altitudeSource != .altsrcUnspecified { - try visitor.visitSingularEnumField(value: _storage._altitudeSource, fieldNumber: 11) + if _storage._altitudeSource != .altUnset { + try visitor.visitSingularEnumField(value: _storage._altitudeSource, fieldNumber: 6) } - if _storage._posTimestamp != 0 { - try visitor.visitSingularFixed32Field(value: _storage._posTimestamp, fieldNumber: 12) + if _storage._timestamp != 0 { + try visitor.visitSingularFixed32Field(value: _storage._timestamp, fieldNumber: 7) } - if _storage._posTimeMillis != 0 { - try visitor.visitSingularInt32Field(value: _storage._posTimeMillis, fieldNumber: 13) + if _storage._timestampMillisAdjust != 0 { + try visitor.visitSingularInt32Field(value: _storage._timestampMillisAdjust, fieldNumber: 8) } if _storage._altitudeHae != 0 { - try visitor.visitSingularSInt32Field(value: _storage._altitudeHae, fieldNumber: 14) + try visitor.visitSingularSInt32Field(value: _storage._altitudeHae, fieldNumber: 9) } - if _storage._altGeoidSep != 0 { - try visitor.visitSingularSInt32Field(value: _storage._altGeoidSep, fieldNumber: 15) + if _storage._altitudeGeoidalSeperation != 0 { + try visitor.visitSingularSInt32Field(value: _storage._altitudeGeoidalSeperation, fieldNumber: 10) } if _storage._pdop != 0 { - try visitor.visitSingularUInt32Field(value: _storage._pdop, fieldNumber: 16) + try visitor.visitSingularUInt32Field(value: _storage._pdop, fieldNumber: 11) } if _storage._hdop != 0 { - try visitor.visitSingularUInt32Field(value: _storage._hdop, fieldNumber: 17) + try visitor.visitSingularUInt32Field(value: _storage._hdop, fieldNumber: 12) } if _storage._vdop != 0 { - try visitor.visitSingularUInt32Field(value: _storage._vdop, fieldNumber: 18) + try visitor.visitSingularUInt32Field(value: _storage._vdop, fieldNumber: 13) } if _storage._gpsAccuracy != 0 { - try visitor.visitSingularUInt32Field(value: _storage._gpsAccuracy, fieldNumber: 19) + try visitor.visitSingularUInt32Field(value: _storage._gpsAccuracy, fieldNumber: 14) } if _storage._groundSpeed != 0 { - try visitor.visitSingularUInt32Field(value: _storage._groundSpeed, fieldNumber: 20) + try visitor.visitSingularUInt32Field(value: _storage._groundSpeed, fieldNumber: 15) } if _storage._groundTrack != 0 { - try visitor.visitSingularUInt32Field(value: _storage._groundTrack, fieldNumber: 21) + try visitor.visitSingularUInt32Field(value: _storage._groundTrack, fieldNumber: 16) } if _storage._fixQuality != 0 { - try visitor.visitSingularUInt32Field(value: _storage._fixQuality, fieldNumber: 22) + try visitor.visitSingularUInt32Field(value: _storage._fixQuality, fieldNumber: 17) } if _storage._fixType != 0 { - try visitor.visitSingularUInt32Field(value: _storage._fixType, fieldNumber: 23) + try visitor.visitSingularUInt32Field(value: _storage._fixType, fieldNumber: 18) } if _storage._satsInView != 0 { - try visitor.visitSingularUInt32Field(value: _storage._satsInView, fieldNumber: 24) + try visitor.visitSingularUInt32Field(value: _storage._satsInView, fieldNumber: 19) } if _storage._sensorID != 0 { - try visitor.visitSingularUInt32Field(value: _storage._sensorID, fieldNumber: 25) + try visitor.visitSingularUInt32Field(value: _storage._sensorID, fieldNumber: 20) } - if _storage._posNextUpdate != 0 { - try visitor.visitSingularUInt32Field(value: _storage._posNextUpdate, fieldNumber: 40) + if _storage._nextUpdate != 0 { + try visitor.visitSingularUInt32Field(value: _storage._nextUpdate, fieldNumber: 21) } - if _storage._posSeqNumber != 0 { - try visitor.visitSingularUInt32Field(value: _storage._posSeqNumber, fieldNumber: 41) + if _storage._seqNumber != 0 { + try visitor.visitSingularUInt32Field(value: _storage._seqNumber, fieldNumber: 22) } } try unknownFields.traverse(visitor: &visitor) @@ -2390,10 +2398,10 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB if _storage._time != rhs_storage._time {return false} if _storage._locationSource != rhs_storage._locationSource {return false} if _storage._altitudeSource != rhs_storage._altitudeSource {return false} - if _storage._posTimestamp != rhs_storage._posTimestamp {return false} - if _storage._posTimeMillis != rhs_storage._posTimeMillis {return false} + if _storage._timestamp != rhs_storage._timestamp {return false} + if _storage._timestampMillisAdjust != rhs_storage._timestampMillisAdjust {return false} if _storage._altitudeHae != rhs_storage._altitudeHae {return false} - if _storage._altGeoidSep != rhs_storage._altGeoidSep {return false} + if _storage._altitudeGeoidalSeperation != rhs_storage._altitudeGeoidalSeperation {return false} if _storage._pdop != rhs_storage._pdop {return false} if _storage._hdop != rhs_storage._hdop {return false} if _storage._vdop != rhs_storage._vdop {return false} @@ -2404,8 +2412,8 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB if _storage._fixType != rhs_storage._fixType {return false} if _storage._satsInView != rhs_storage._satsInView {return false} if _storage._sensorID != rhs_storage._sensorID {return false} - if _storage._posNextUpdate != rhs_storage._posNextUpdate {return false} - if _storage._posSeqNumber != rhs_storage._posSeqNumber {return false} + if _storage._nextUpdate != rhs_storage._nextUpdate {return false} + if _storage._seqNumber != rhs_storage._seqNumber {return false} return true } if !storagesAreEqual {return false} @@ -2417,20 +2425,20 @@ extension Position: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB extension Position.LocSource: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "LOCSRC_UNSPECIFIED"), - 1: .same(proto: "LOCSRC_MANUAL_ENTRY"), - 2: .same(proto: "LOCSRC_GPS_INTERNAL"), - 3: .same(proto: "LOCSRC_GPS_EXTERNAL"), + 0: .same(proto: "LOC_UNSET"), + 1: .same(proto: "LOC_MANUAL"), + 2: .same(proto: "LOC_INTERNAL"), + 3: .same(proto: "LOC_EXTERNAL"), ] } extension Position.AltSource: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ALTSRC_UNSPECIFIED"), - 1: .same(proto: "ALTSRC_MANUAL_ENTRY"), - 2: .same(proto: "ALTSRC_GPS_INTERNAL"), - 3: .same(proto: "ALTSRC_GPS_EXTERNAL"), - 4: .same(proto: "ALTSRC_BAROMETRIC"), + 0: .same(proto: "ALT_UNSET"), + 1: .same(proto: "ALT_MANUAL"), + 2: .same(proto: "ALT_INTERNAL"), + 3: .same(proto: "ALT_EXTERNAL"), + 4: .same(proto: "ALT_BAROMETRIC"), ] } @@ -2441,8 +2449,8 @@ extension User: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, 2: .standard(proto: "long_name"), 3: .standard(proto: "short_name"), 4: .same(proto: "macaddr"), - 6: .standard(proto: "hw_model"), - 7: .standard(proto: "is_licensed"), + 5: .standard(proto: "hw_model"), + 6: .standard(proto: "is_licensed"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -2455,8 +2463,8 @@ extension User: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, case 2: try { try decoder.decodeSingularStringField(value: &self.longName) }() case 3: try { try decoder.decodeSingularStringField(value: &self.shortName) }() case 4: try { try decoder.decodeSingularBytesField(value: &self.macaddr) }() - case 6: try { try decoder.decodeSingularEnumField(value: &self.hwModel) }() - case 7: try { try decoder.decodeSingularBoolField(value: &self.isLicensed) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self.hwModel) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self.isLicensed) }() default: break } } @@ -2476,10 +2484,10 @@ extension User: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, try visitor.visitSingularBytesField(value: self.macaddr, fieldNumber: 4) } if self.hwModel != .unset { - try visitor.visitSingularEnumField(value: self.hwModel, fieldNumber: 6) + try visitor.visitSingularEnumField(value: self.hwModel, fieldNumber: 5) } if self.isLicensed != false { - try visitor.visitSingularBoolField(value: self.isLicensed, fieldNumber: 7) + try visitor.visitSingularBoolField(value: self.isLicensed, fieldNumber: 6) } try unknownFields.traverse(visitor: &visitor) } @@ -2499,7 +2507,7 @@ extension User: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, extension RouteDiscovery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = "RouteDiscovery" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "route"), + 1: .same(proto: "route"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -2508,7 +2516,7 @@ extension RouteDiscovery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 2: try { try decoder.decodeRepeatedFixed32Field(value: &self.route) }() + case 1: try { try decoder.decodeRepeatedFixed32Field(value: &self.route) }() default: break } } @@ -2516,7 +2524,7 @@ extension RouteDiscovery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement func traverse(visitor: inout V) throws { if !self.route.isEmpty { - try visitor.visitPackedFixed32Field(value: self.route, fieldNumber: 2) + try visitor.visitPackedFixed32Field(value: self.route, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } @@ -2780,11 +2788,11 @@ extension MeshPacket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio 6: .same(proto: "id"), 7: .standard(proto: "rx_time"), 8: .standard(proto: "rx_snr"), - 10: .standard(proto: "hop_limit"), - 11: .standard(proto: "want_ack"), - 12: .same(proto: "priority"), - 13: .standard(proto: "rx_rssi"), - 15: .same(proto: "delayed"), + 9: .standard(proto: "hop_limit"), + 10: .standard(proto: "want_ack"), + 11: .same(proto: "priority"), + 12: .standard(proto: "rx_rssi"), + 13: .same(proto: "delayed"), ] fileprivate class _StorageClass { @@ -2863,11 +2871,11 @@ extension MeshPacket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio case 6: try { try decoder.decodeSingularFixed32Field(value: &_storage._id) }() case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._rxTime) }() case 8: try { try decoder.decodeSingularFloatField(value: &_storage._rxSnr) }() - case 10: try { try decoder.decodeSingularUInt32Field(value: &_storage._hopLimit) }() - case 11: try { try decoder.decodeSingularBoolField(value: &_storage._wantAck) }() - case 12: try { try decoder.decodeSingularEnumField(value: &_storage._priority) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._rxRssi) }() - case 15: try { try decoder.decodeSingularEnumField(value: &_storage._delayed) }() + case 9: try { try decoder.decodeSingularUInt32Field(value: &_storage._hopLimit) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._wantAck) }() + case 11: try { try decoder.decodeSingularEnumField(value: &_storage._priority) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._rxRssi) }() + case 13: try { try decoder.decodeSingularEnumField(value: &_storage._delayed) }() default: break } } @@ -2910,19 +2918,19 @@ extension MeshPacket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio try visitor.visitSingularFloatField(value: _storage._rxSnr, fieldNumber: 8) } if _storage._hopLimit != 0 { - try visitor.visitSingularUInt32Field(value: _storage._hopLimit, fieldNumber: 10) + try visitor.visitSingularUInt32Field(value: _storage._hopLimit, fieldNumber: 9) } if _storage._wantAck != false { - try visitor.visitSingularBoolField(value: _storage._wantAck, fieldNumber: 11) + try visitor.visitSingularBoolField(value: _storage._wantAck, fieldNumber: 10) } if _storage._priority != .unset { - try visitor.visitSingularEnumField(value: _storage._priority, fieldNumber: 12) + try visitor.visitSingularEnumField(value: _storage._priority, fieldNumber: 11) } if _storage._rxRssi != 0 { - try visitor.visitSingularInt32Field(value: _storage._rxRssi, fieldNumber: 13) + try visitor.visitSingularInt32Field(value: _storage._rxRssi, fieldNumber: 12) } if _storage._delayed != .noDelay { - try visitor.visitSingularEnumField(value: _storage._delayed, fieldNumber: 15) + try visitor.visitSingularEnumField(value: _storage._delayed, fieldNumber: 13) } } try unknownFields.traverse(visitor: &visitor) @@ -3045,20 +3053,20 @@ extension MyNodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "my_node_num"), 2: .standard(proto: "has_gps"), - 15: .standard(proto: "max_channels"), - 6: .standard(proto: "firmware_version"), - 7: .standard(proto: "error_code"), - 8: .standard(proto: "error_address"), - 9: .standard(proto: "error_count"), - 10: .standard(proto: "reboot_count"), - 11: .same(proto: "bitrate"), - 13: .standard(proto: "message_timeout_msec"), - 14: .standard(proto: "min_app_version"), - 16: .standard(proto: "air_period_tx"), - 17: .standard(proto: "air_period_rx"), - 18: .standard(proto: "has_wifi"), - 19: .standard(proto: "channel_utilization"), - 20: .standard(proto: "air_util_tx"), + 3: .standard(proto: "max_channels"), + 4: .standard(proto: "firmware_version"), + 5: .standard(proto: "error_code"), + 6: .standard(proto: "error_address"), + 7: .standard(proto: "error_count"), + 8: .standard(proto: "reboot_count"), + 9: .same(proto: "bitrate"), + 10: .standard(proto: "message_timeout_msec"), + 11: .standard(proto: "min_app_version"), + 12: .standard(proto: "air_period_tx"), + 13: .standard(proto: "air_period_rx"), + 14: .standard(proto: "has_wifi"), + 15: .standard(proto: "channel_utilization"), + 16: .standard(proto: "air_util_tx"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -3069,20 +3077,20 @@ extension MyNodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio switch fieldNumber { case 1: try { try decoder.decodeSingularUInt32Field(value: &self.myNodeNum) }() case 2: try { try decoder.decodeSingularBoolField(value: &self.hasGps_p) }() - case 6: try { try decoder.decodeSingularStringField(value: &self.firmwareVersion) }() - case 7: try { try decoder.decodeSingularEnumField(value: &self.errorCode) }() - case 8: try { try decoder.decodeSingularUInt32Field(value: &self.errorAddress) }() - case 9: try { try decoder.decodeSingularUInt32Field(value: &self.errorCount) }() - case 10: try { try decoder.decodeSingularUInt32Field(value: &self.rebootCount) }() - case 11: try { try decoder.decodeSingularFloatField(value: &self.bitrate) }() - case 13: try { try decoder.decodeSingularUInt32Field(value: &self.messageTimeoutMsec) }() - case 14: try { try decoder.decodeSingularUInt32Field(value: &self.minAppVersion) }() - case 15: try { try decoder.decodeSingularUInt32Field(value: &self.maxChannels) }() - case 16: try { try decoder.decodeRepeatedUInt32Field(value: &self.airPeriodTx) }() - case 17: try { try decoder.decodeRepeatedUInt32Field(value: &self.airPeriodRx) }() - case 18: try { try decoder.decodeSingularBoolField(value: &self.hasWifi_p) }() - case 19: try { try decoder.decodeSingularFloatField(value: &self.channelUtilization) }() - case 20: try { try decoder.decodeSingularFloatField(value: &self.airUtilTx) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &self.maxChannels) }() + case 4: try { try decoder.decodeSingularStringField(value: &self.firmwareVersion) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self.errorCode) }() + case 6: try { try decoder.decodeSingularUInt32Field(value: &self.errorAddress) }() + case 7: try { try decoder.decodeSingularUInt32Field(value: &self.errorCount) }() + case 8: try { try decoder.decodeSingularUInt32Field(value: &self.rebootCount) }() + case 9: try { try decoder.decodeSingularFloatField(value: &self.bitrate) }() + case 10: try { try decoder.decodeSingularUInt32Field(value: &self.messageTimeoutMsec) }() + case 11: try { try decoder.decodeSingularUInt32Field(value: &self.minAppVersion) }() + case 12: try { try decoder.decodeRepeatedUInt32Field(value: &self.airPeriodTx) }() + case 13: try { try decoder.decodeRepeatedUInt32Field(value: &self.airPeriodRx) }() + case 14: try { try decoder.decodeSingularBoolField(value: &self.hasWifi_p) }() + case 15: try { try decoder.decodeSingularFloatField(value: &self.channelUtilization) }() + case 16: try { try decoder.decodeSingularFloatField(value: &self.airUtilTx) }() default: break } } @@ -3095,47 +3103,47 @@ extension MyNodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio if self.hasGps_p != false { try visitor.visitSingularBoolField(value: self.hasGps_p, fieldNumber: 2) } + if self.maxChannels != 0 { + try visitor.visitSingularUInt32Field(value: self.maxChannels, fieldNumber: 3) + } if !self.firmwareVersion.isEmpty { - try visitor.visitSingularStringField(value: self.firmwareVersion, fieldNumber: 6) + try visitor.visitSingularStringField(value: self.firmwareVersion, fieldNumber: 4) } if self.errorCode != .none { - try visitor.visitSingularEnumField(value: self.errorCode, fieldNumber: 7) + try visitor.visitSingularEnumField(value: self.errorCode, fieldNumber: 5) } if self.errorAddress != 0 { - try visitor.visitSingularUInt32Field(value: self.errorAddress, fieldNumber: 8) + try visitor.visitSingularUInt32Field(value: self.errorAddress, fieldNumber: 6) } if self.errorCount != 0 { - try visitor.visitSingularUInt32Field(value: self.errorCount, fieldNumber: 9) + try visitor.visitSingularUInt32Field(value: self.errorCount, fieldNumber: 7) } if self.rebootCount != 0 { - try visitor.visitSingularUInt32Field(value: self.rebootCount, fieldNumber: 10) + try visitor.visitSingularUInt32Field(value: self.rebootCount, fieldNumber: 8) } if self.bitrate != 0 { - try visitor.visitSingularFloatField(value: self.bitrate, fieldNumber: 11) + try visitor.visitSingularFloatField(value: self.bitrate, fieldNumber: 9) } if self.messageTimeoutMsec != 0 { - try visitor.visitSingularUInt32Field(value: self.messageTimeoutMsec, fieldNumber: 13) + try visitor.visitSingularUInt32Field(value: self.messageTimeoutMsec, fieldNumber: 10) } if self.minAppVersion != 0 { - try visitor.visitSingularUInt32Field(value: self.minAppVersion, fieldNumber: 14) - } - if self.maxChannels != 0 { - try visitor.visitSingularUInt32Field(value: self.maxChannels, fieldNumber: 15) + try visitor.visitSingularUInt32Field(value: self.minAppVersion, fieldNumber: 11) } if !self.airPeriodTx.isEmpty { - try visitor.visitPackedUInt32Field(value: self.airPeriodTx, fieldNumber: 16) + try visitor.visitPackedUInt32Field(value: self.airPeriodTx, fieldNumber: 12) } if !self.airPeriodRx.isEmpty { - try visitor.visitPackedUInt32Field(value: self.airPeriodRx, fieldNumber: 17) + try visitor.visitPackedUInt32Field(value: self.airPeriodRx, fieldNumber: 13) } if self.hasWifi_p != false { - try visitor.visitSingularBoolField(value: self.hasWifi_p, fieldNumber: 18) + try visitor.visitSingularBoolField(value: self.hasWifi_p, fieldNumber: 14) } if self.channelUtilization != 0 { - try visitor.visitSingularFloatField(value: self.channelUtilization, fieldNumber: 19) + try visitor.visitSingularFloatField(value: self.channelUtilization, fieldNumber: 15) } if self.airUtilTx != 0 { - try visitor.visitSingularFloatField(value: self.airUtilTx, fieldNumber: 20) + try visitor.visitSingularFloatField(value: self.airUtilTx, fieldNumber: 16) } try unknownFields.traverse(visitor: &visitor) } @@ -3228,14 +3236,14 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation static let protoMessageName: String = "FromRadio" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .same(proto: "id"), - 11: .same(proto: "packet"), + 2: .same(proto: "packet"), 3: .standard(proto: "my_info"), 4: .standard(proto: "node_info"), - 6: .same(proto: "config"), - 7: .standard(proto: "log_record"), - 8: .standard(proto: "config_complete_id"), - 9: .same(proto: "rebooted"), - 10: .same(proto: "moduleConfig"), + 5: .same(proto: "config"), + 6: .standard(proto: "log_record"), + 7: .standard(proto: "config_complete_id"), + 8: .same(proto: "rebooted"), + 9: .same(proto: "moduleConfig"), ] fileprivate class _StorageClass { @@ -3268,6 +3276,19 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularUInt32Field(value: &_storage._id) }() + case 2: try { + var v: MeshPacket? + var hadOneofValue = false + if let current = _storage._payloadVariant { + hadOneofValue = true + if case .packet(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._payloadVariant = .packet(v) + } + }() case 3: try { var v: MyNodeInfo? var hadOneofValue = false @@ -3294,7 +3315,7 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation _storage._payloadVariant = .nodeInfo(v) } }() - case 6: try { + case 5: try { var v: Config? var hadOneofValue = false if let current = _storage._payloadVariant { @@ -3307,7 +3328,7 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation _storage._payloadVariant = .config(v) } }() - case 7: try { + case 6: try { var v: LogRecord? var hadOneofValue = false if let current = _storage._payloadVariant { @@ -3320,7 +3341,7 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation _storage._payloadVariant = .logRecord(v) } }() - case 8: try { + case 7: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) if let v = v { @@ -3328,7 +3349,7 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation _storage._payloadVariant = .configCompleteID(v) } }() - case 9: try { + case 8: try { var v: Bool? try decoder.decodeSingularBoolField(value: &v) if let v = v { @@ -3336,7 +3357,7 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation _storage._payloadVariant = .rebooted(v) } }() - case 10: try { + case 9: try { var v: ModuleConfig? var hadOneofValue = false if let current = _storage._payloadVariant { @@ -3349,19 +3370,6 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation _storage._payloadVariant = .moduleConfig(v) } }() - case 11: try { - var v: MeshPacket? - var hadOneofValue = false - if let current = _storage._payloadVariant { - hadOneofValue = true - if case .packet(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._payloadVariant = .packet(v) - } - }() default: break } } @@ -3378,6 +3386,10 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation try visitor.visitSingularUInt32Field(value: _storage._id, fieldNumber: 1) } switch _storage._payloadVariant { + case .packet?: try { + guard case .packet(let v)? = _storage._payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() case .myInfo?: try { guard case .myInfo(let v)? = _storage._payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 3) @@ -3388,27 +3400,23 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation }() case .config?: try { guard case .config(let v)? = _storage._payloadVariant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) }() case .logRecord?: try { guard case .logRecord(let v)? = _storage._payloadVariant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) }() case .configCompleteID?: try { guard case .configCompleteID(let v)? = _storage._payloadVariant else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 8) + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 7) }() case .rebooted?: try { guard case .rebooted(let v)? = _storage._payloadVariant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 9) + try visitor.visitSingularBoolField(value: v, fieldNumber: 8) }() case .moduleConfig?: try { guard case .moduleConfig(let v)? = _storage._payloadVariant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 10) - }() - case .packet?: try { - guard case .packet(let v)? = _storage._payloadVariant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) }() case nil: break } @@ -3435,10 +3443,10 @@ extension FromRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation extension ToRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = "ToRadio" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "packet"), - 3: .standard(proto: "peer_info"), - 100: .standard(proto: "want_config_id"), - 104: .same(proto: "disconnect"), + 1: .same(proto: "packet"), + 2: .standard(proto: "peer_info"), + 3: .standard(proto: "want_config_id"), + 4: .same(proto: "disconnect"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -3447,7 +3455,7 @@ extension ToRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBa // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 2: try { + case 1: try { var v: MeshPacket? var hadOneofValue = false if let current = self.payloadVariant { @@ -3460,7 +3468,7 @@ extension ToRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBa self.payloadVariant = .packet(v) } }() - case 3: try { + case 2: try { var v: ToRadio.PeerInfo? var hadOneofValue = false if let current = self.payloadVariant { @@ -3473,7 +3481,7 @@ extension ToRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBa self.payloadVariant = .peerInfo(v) } }() - case 100: try { + case 3: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) if let v = v { @@ -3481,7 +3489,7 @@ extension ToRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBa self.payloadVariant = .wantConfigID(v) } }() - case 104: try { + case 4: try { var v: Bool? try decoder.decodeSingularBoolField(value: &v) if let v = v { @@ -3502,19 +3510,19 @@ extension ToRadio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBa switch self.payloadVariant { case .packet?: try { guard case .packet(let v)? = self.payloadVariant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) }() case .peerInfo?: try { guard case .peerInfo(let v)? = self.payloadVariant else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) }() case .wantConfigID?: try { guard case .wantConfigID(let v)? = self.payloadVariant else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 100) + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) }() case .disconnect?: try { guard case .disconnect(let v)? = self.payloadVariant else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 104) + try visitor.visitSingularBoolField(value: v, fieldNumber: 4) }() case nil: break } diff --git a/Meshtastic/Protobufs/module_config.pb.swift b/Meshtastic/Protobufs/module_config.pb.swift index 44f61043..23a8117d 100644 --- a/Meshtastic/Protobufs/module_config.pb.swift +++ b/Meshtastic/Protobufs/module_config.pb.swift @@ -248,7 +248,7 @@ struct ModuleConfig { /// /// TODO: REPLACE - var mode: ModuleConfig.SerialConfig.Serial_Mode = .modeDefault + var mode: ModuleConfig.SerialConfig.Serial_Mode = .default var unknownFields = SwiftProtobuf.UnknownStorage() @@ -328,29 +328,29 @@ struct ModuleConfig { /// TODO: REPLACE enum Serial_Mode: SwiftProtobuf.Enum { typealias RawValue = Int - case modeDefault // = 0 - case modeSimple // = 1 - case modeProto // = 2 + case `default` // = 0 + case simple // = 1 + case proto // = 2 case UNRECOGNIZED(Int) init() { - self = .modeDefault + self = .default } init?(rawValue: Int) { switch rawValue { - case 0: self = .modeDefault - case 1: self = .modeSimple - case 2: self = .modeProto + case 0: self = .default + case 1: self = .simple + case 2: self = .proto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .modeDefault: return 0 - case .modeSimple: return 1 - case .modeProto: return 2 + case .default: return 0 + case .simple: return 1 + case .proto: return 2 case .UNRECOGNIZED(let i): return i } } @@ -512,15 +512,15 @@ struct ModuleConfig { /// /// Generate input event on CW of this kind. - var inputbrokerEventCw: ModuleConfig.CannedMessageConfig.InputEventChar = .keyNone + var inputbrokerEventCw: ModuleConfig.CannedMessageConfig.InputEventChar = .none /// /// Generate input event on CCW of this kind. - var inputbrokerEventCcw: ModuleConfig.CannedMessageConfig.InputEventChar = .keyNone + var inputbrokerEventCcw: ModuleConfig.CannedMessageConfig.InputEventChar = .none /// /// Generate input event on Press of this kind. - var inputbrokerEventPress: ModuleConfig.CannedMessageConfig.InputEventChar = .keyNone + var inputbrokerEventPress: ModuleConfig.CannedMessageConfig.InputEventChar = .none /// /// Enable the Up/Down/Select input device. Can be RAK rotary encoder or 3 buttons. Uses the a/b/press definitions from inputbroker. @@ -549,65 +549,65 @@ struct ModuleConfig { /// /// TODO: REPLACE - case keyNone // = 0 + case none // = 0 /// /// TODO: REPLACE - case keyUp // = 17 + case up // = 17 /// /// TODO: REPLACE - case keyDown // = 18 + case down // = 18 /// /// TODO: REPLACE - case keyLeft // = 19 + case left // = 19 /// /// TODO: REPLACE - case keyRight // = 20 + case right // = 20 /// /// '\n' - case keySelect // = 10 + case select // = 10 /// /// TODO: REPLACE - case keyBack // = 27 + case back // = 27 /// /// TODO: REPLACE - case keyCancel // = 24 + case cancel // = 24 case UNRECOGNIZED(Int) init() { - self = .keyNone + self = .none } init?(rawValue: Int) { switch rawValue { - case 0: self = .keyNone - case 10: self = .keySelect - case 17: self = .keyUp - case 18: self = .keyDown - case 19: self = .keyLeft - case 20: self = .keyRight - case 24: self = .keyCancel - case 27: self = .keyBack + case 0: self = .none + case 10: self = .select + case 17: self = .up + case 18: self = .down + case 19: self = .left + case 20: self = .right + case 24: self = .cancel + case 27: self = .back default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .keyNone: return 0 - case .keySelect: return 10 - case .keyUp: return 17 - case .keyDown: return 18 - case .keyLeft: return 19 - case .keyRight: return 20 - case .keyCancel: return 24 - case .keyBack: return 27 + case .none: return 0 + case .select: return 10 + case .up: return 17 + case .down: return 18 + case .left: return 19 + case .right: return 20 + case .cancel: return 24 + case .back: return 27 case .UNRECOGNIZED(let i): return i } } @@ -647,23 +647,23 @@ extension ModuleConfig.SerialConfig.Serial_Baud: CaseIterable { extension ModuleConfig.SerialConfig.Serial_Mode: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [ModuleConfig.SerialConfig.Serial_Mode] = [ - .modeDefault, - .modeSimple, - .modeProto, + .default, + .simple, + .proto, ] } extension ModuleConfig.CannedMessageConfig.InputEventChar: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [ModuleConfig.CannedMessageConfig.InputEventChar] = [ - .keyNone, - .keyUp, - .keyDown, - .keyLeft, - .keyRight, - .keySelect, - .keyBack, - .keyCancel, + .none, + .up, + .down, + .left, + .right, + .select, + .back, + .cancel, ] } @@ -957,7 +957,7 @@ extension ModuleConfig.SerialConfig: SwiftProtobuf.Message, SwiftProtobuf._Messa if self.timeout != 0 { try visitor.visitSingularUInt32Field(value: self.timeout, fieldNumber: 6) } - if self.mode != .modeDefault { + if self.mode != .default { try visitor.visitSingularEnumField(value: self.mode, fieldNumber: 7) } try unknownFields.traverse(visitor: &visitor) @@ -978,7 +978,7 @@ extension ModuleConfig.SerialConfig: SwiftProtobuf.Message, SwiftProtobuf._Messa extension ModuleConfig.SerialConfig.Serial_Baud: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "BAUD_Default"), + 0: .same(proto: "BAUD_DEFAULT"), 1: .same(proto: "BAUD_110"), 2: .same(proto: "BAUD_300"), 3: .same(proto: "BAUD_600"), @@ -999,9 +999,9 @@ extension ModuleConfig.SerialConfig.Serial_Baud: SwiftProtobuf._ProtoNameProvidi extension ModuleConfig.SerialConfig.Serial_Mode: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "MODE_Default"), - 1: .same(proto: "MODE_SIMPLE"), - 2: .same(proto: "MODE_PROTO"), + 0: .same(proto: "DEFAULT"), + 1: .same(proto: "SIMPLE"), + 2: .same(proto: "PROTO"), ] } @@ -1174,7 +1174,7 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me 2: .standard(proto: "environment_update_interval"), 3: .standard(proto: "environment_measurement_enabled"), 4: .standard(proto: "environment_screen_enabled"), - 7: .standard(proto: "environment_display_fahrenheit"), + 5: .standard(proto: "environment_display_fahrenheit"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -1187,7 +1187,7 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me case 2: try { try decoder.decodeSingularUInt32Field(value: &self.environmentUpdateInterval) }() case 3: try { try decoder.decodeSingularBoolField(value: &self.environmentMeasurementEnabled) }() case 4: try { try decoder.decodeSingularBoolField(value: &self.environmentScreenEnabled) }() - case 7: try { try decoder.decodeSingularBoolField(value: &self.environmentDisplayFahrenheit) }() + case 5: try { try decoder.decodeSingularBoolField(value: &self.environmentDisplayFahrenheit) }() default: break } } @@ -1207,7 +1207,7 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me try visitor.visitSingularBoolField(value: self.environmentScreenEnabled, fieldNumber: 4) } if self.environmentDisplayFahrenheit != false { - try visitor.visitSingularBoolField(value: self.environmentDisplayFahrenheit, fieldNumber: 7) + try visitor.visitSingularBoolField(value: self.environmentDisplayFahrenheit, fieldNumber: 5) } try unknownFields.traverse(visitor: &visitor) } @@ -1274,13 +1274,13 @@ extension ModuleConfig.CannedMessageConfig: SwiftProtobuf.Message, SwiftProtobuf if self.inputbrokerPinPress != 0 { try visitor.visitSingularUInt32Field(value: self.inputbrokerPinPress, fieldNumber: 4) } - if self.inputbrokerEventCw != .keyNone { + if self.inputbrokerEventCw != .none { try visitor.visitSingularEnumField(value: self.inputbrokerEventCw, fieldNumber: 5) } - if self.inputbrokerEventCcw != .keyNone { + if self.inputbrokerEventCcw != .none { try visitor.visitSingularEnumField(value: self.inputbrokerEventCcw, fieldNumber: 6) } - if self.inputbrokerEventPress != .keyNone { + if self.inputbrokerEventPress != .none { try visitor.visitSingularEnumField(value: self.inputbrokerEventPress, fieldNumber: 7) } if self.updown1Enabled != false { @@ -1317,13 +1317,13 @@ extension ModuleConfig.CannedMessageConfig: SwiftProtobuf.Message, SwiftProtobuf extension ModuleConfig.CannedMessageConfig.InputEventChar: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "KEY_NONE"), - 10: .same(proto: "KEY_SELECT"), - 17: .same(proto: "KEY_UP"), - 18: .same(proto: "KEY_DOWN"), - 19: .same(proto: "KEY_LEFT"), - 20: .same(proto: "KEY_RIGHT"), - 24: .same(proto: "KEY_CANCEL"), - 27: .same(proto: "KEY_BACK"), + 0: .same(proto: "NONE"), + 10: .same(proto: "SELECT"), + 17: .same(proto: "UP"), + 18: .same(proto: "DOWN"), + 19: .same(proto: "LEFT"), + 20: .same(proto: "RIGHT"), + 24: .same(proto: "CANCEL"), + 27: .same(proto: "BACK"), ] } diff --git a/Meshtastic/Protobufs/telemetry.pb.swift b/Meshtastic/Protobufs/telemetry.pb.swift index 55f9e280..85e95036 100644 --- a/Meshtastic/Protobufs/telemetry.pb.swift +++ b/Meshtastic/Protobufs/telemetry.pb.swift @@ -27,7 +27,7 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { /// /// No external telemetry sensor explicitly set - case unset // = 0 + case sensorUnset // = 0 /// /// High accuracy temperature, pressure, humidity @@ -55,12 +55,12 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { case UNRECOGNIZED(Int) init() { - self = .unset + self = .sensorUnset } init?(rawValue: Int) { switch rawValue { - case 0: self = .unset + case 0: self = .sensorUnset case 1: self = .bme280 case 2: self = .bme680 case 3: self = .mcp9808 @@ -73,7 +73,7 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { var rawValue: Int { switch self { - case .unset: return 0 + case .sensorUnset: return 0 case .bme280: return 1 case .bme680: return 2 case .mcp9808: return 3 @@ -91,7 +91,7 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { extension TelemetrySensorType: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [TelemetrySensorType] = [ - .unset, + .sensorUnset, .bme280, .bme680, .mcp9808, @@ -249,7 +249,7 @@ extension Telemetry.OneOf_Variant: @unchecked Sendable {} extension TelemetrySensorType: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSET"), + 0: .same(proto: "SENSOR_UNSET"), 1: .same(proto: "BME280"), 2: .same(proto: "BME680"), 3: .same(proto: "MCP9808"), diff --git a/Meshtastic/Views/Settings/Config/Module/CannedMessagesConfig.swift b/Meshtastic/Views/Settings/Config/Module/CannedMessagesConfig.swift index 2f7e8908..3e8373b7 100644 --- a/Meshtastic/Views/Settings/Config/Module/CannedMessagesConfig.swift +++ b/Meshtastic/Views/Settings/Config/Module/CannedMessagesConfig.swift @@ -76,21 +76,21 @@ enum InputEventChars: Int, CaseIterable, Identifiable { switch self { case .keyNone: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyNone + return ModuleConfig.CannedMessageConfig.InputEventChar.none case .keyUp: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyUp + return ModuleConfig.CannedMessageConfig.InputEventChar.up case .keyDown: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyDown + return ModuleConfig.CannedMessageConfig.InputEventChar.down case .keyLeft: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyLeft + return ModuleConfig.CannedMessageConfig.InputEventChar.left case .keyRight: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyRight + return ModuleConfig.CannedMessageConfig.InputEventChar.right case .keySelect: - return ModuleConfig.CannedMessageConfig.InputEventChar.keySelect + return ModuleConfig.CannedMessageConfig.InputEventChar.select case .keyBack: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyBack + return ModuleConfig.CannedMessageConfig.InputEventChar.back case .keyCancel: - return ModuleConfig.CannedMessageConfig.InputEventChar.keyCancel + return ModuleConfig.CannedMessageConfig.InputEventChar.cancel } } } diff --git a/Meshtastic/Views/Settings/Config/Module/SerialConfig.swift b/Meshtastic/Views/Settings/Config/Module/SerialConfig.swift index 99f183cf..8e15c39c 100644 --- a/Meshtastic/Views/Settings/Config/Module/SerialConfig.swift +++ b/Meshtastic/Views/Settings/Config/Module/SerialConfig.swift @@ -130,11 +130,11 @@ enum SerialModeTypes: Int, CaseIterable, Identifiable { switch self { case .modeDefault: - return ModuleConfig.SerialConfig.Serial_Mode.modeDefault + return ModuleConfig.SerialConfig.Serial_Mode.default case .modeSimple: - return ModuleConfig.SerialConfig.Serial_Mode.modeSimple + return ModuleConfig.SerialConfig.Serial_Mode.simple case .modeProto: - return ModuleConfig.SerialConfig.Serial_Mode.modeProto + return ModuleConfig.SerialConfig.Serial_Mode.proto } } }