diff --git a/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift index 188799b9..2b539ef6 100644 --- a/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift +++ b/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift @@ -292,6 +292,17 @@ public struct AdminMessage: @unchecked Sendable { set {payloadVariant = .removeBackupPreferences(newValue)} } + /// + /// Send an input event to the node. + /// This is used to trigger physical input events like button presses, touch events, etc. + public var sendInputEvent: AdminMessage.InputEvent { + get { + if case .sendInputEvent(let v)? = payloadVariant {return v} + return AdminMessage.InputEvent() + } + set {payloadVariant = .sendInputEvent(newValue)} + } + /// /// Set the owner for this node public var setOwner: User { @@ -663,6 +674,10 @@ public struct AdminMessage: @unchecked Sendable { /// Remove backups of the node's preferences case removeBackupPreferences(AdminMessage.BackupLocation) /// + /// Send an input event to the node. + /// This is used to trigger physical input events like button presses, touch events, etc. + case sendInputEvent(AdminMessage.InputEvent) + /// /// Set the owner for this node case setOwner(User) /// @@ -1014,6 +1029,34 @@ public struct AdminMessage: @unchecked Sendable { } + /// + /// Input event message to be sent to the node. + public struct InputEvent: Sendable { + // SwiftProtobuf.Message conformance is added in an extension below. See the + // `Message` and `Message+*Additions` files in the SwiftProtobuf library for + // methods supported on all messages. + + /// + /// The input event code + public var eventCode: UInt32 = 0 + + /// + /// Keyboard character code + public var kbChar: UInt32 = 0 + + /// + /// The touch X coordinate + public var touchX: UInt32 = 0 + + /// + /// The touch Y coordinate + public var touchY: UInt32 = 0 + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + } + public init() {} } @@ -1083,6 +1126,10 @@ public struct SharedContact: Sendable { /// Clears the value of `user`. Subsequent reads from it will return its default value. public mutating func clearUser() {self._user = nil} + /// + /// Add this contact to the blocked / ignored list + public var shouldIgnore: Bool = false + public var unknownFields = SwiftProtobuf.UnknownStorage() public init() {} @@ -1215,6 +1262,7 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat 24: .standard(proto: "backup_preferences"), 25: .standard(proto: "restore_preferences"), 26: .standard(proto: "remove_backup_preferences"), + 27: .standard(proto: "send_input_event"), 32: .standard(proto: "set_owner"), 33: .standard(proto: "set_channel"), 34: .standard(proto: "set_config"), @@ -1491,6 +1539,19 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat self.payloadVariant = .removeBackupPreferences(v) } }() + case 27: try { + var v: AdminMessage.InputEvent? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .sendInputEvent(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .sendInputEvent(v) + } + }() case 32: try { var v: User? var hadOneofValue = false @@ -1872,6 +1933,10 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat guard case .removeBackupPreferences(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularEnumField(value: v, fieldNumber: 26) }() + case .sendInputEvent?: try { + guard case .sendInputEvent(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + }() case .setOwner?: try { guard case .setOwner(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 32) @@ -2040,6 +2105,56 @@ extension AdminMessage.BackupLocation: SwiftProtobuf._ProtoNameProviding { ] } +extension AdminMessage.InputEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = AdminMessage.protoMessageName + ".InputEvent" + public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .standard(proto: "event_code"), + 2: .standard(proto: "kb_char"), + 3: .standard(proto: "touch_x"), + 4: .standard(proto: "touch_y"), + ] + + public mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // 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 fieldNumber { + case 1: try { try decoder.decodeSingularUInt32Field(value: &self.eventCode) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self.kbChar) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &self.touchX) }() + case 4: try { try decoder.decodeSingularUInt32Field(value: &self.touchY) }() + default: break + } + } + } + + public func traverse(visitor: inout V) throws { + if self.eventCode != 0 { + try visitor.visitSingularUInt32Field(value: self.eventCode, fieldNumber: 1) + } + if self.kbChar != 0 { + try visitor.visitSingularUInt32Field(value: self.kbChar, fieldNumber: 2) + } + if self.touchX != 0 { + try visitor.visitSingularUInt32Field(value: self.touchX, fieldNumber: 3) + } + if self.touchY != 0 { + try visitor.visitSingularUInt32Field(value: self.touchY, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: AdminMessage.InputEvent, rhs: AdminMessage.InputEvent) -> Bool { + if lhs.eventCode != rhs.eventCode {return false} + if lhs.kbChar != rhs.kbChar {return false} + if lhs.touchX != rhs.touchX {return false} + if lhs.touchY != rhs.touchY {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension HamParameters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".HamParameters" public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ @@ -2127,6 +2242,7 @@ extension SharedContact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "node_num"), 2: .same(proto: "user"), + 3: .standard(proto: "should_ignore"), ] public mutating func decodeMessage(decoder: inout D) throws { @@ -2137,6 +2253,7 @@ extension SharedContact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa switch fieldNumber { case 1: try { try decoder.decodeSingularUInt32Field(value: &self.nodeNum) }() case 2: try { try decoder.decodeSingularMessageField(value: &self._user) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self.shouldIgnore) }() default: break } } @@ -2153,12 +2270,16 @@ extension SharedContact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa try { if let v = self._user { try visitor.visitSingularMessageField(value: v, fieldNumber: 2) } }() + if self.shouldIgnore != false { + try visitor.visitSingularBoolField(value: self.shouldIgnore, fieldNumber: 3) + } try unknownFields.traverse(visitor: &visitor) } public static func ==(lhs: SharedContact, rhs: SharedContact) -> Bool { if lhs.nodeNum != rhs.nodeNum {return false} if lhs._user != rhs._user {return false} + if lhs.shouldIgnore != rhs.shouldIgnore {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift index 12a57c69..e37bc908 100644 --- a/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift +++ b/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift @@ -189,6 +189,11 @@ public struct Config: Sendable { /// If true, disable the default blinking LED (LED_PIN) behavior on the device public var ledHeartbeatDisabled: Bool = false + /// + /// Controls buzzer behavior for audio feedback + /// Defaults to ENABLED + public var buzzerMode: Config.DeviceConfig.BuzzerMode = .allEnabled + public var unknownFields = SwiftProtobuf.UnknownStorage() /// @@ -406,6 +411,67 @@ public struct Config: Sendable { } + /// + /// Defines buzzer behavior for audio feedback + public enum BuzzerMode: SwiftProtobuf.Enum, Swift.CaseIterable { + public typealias RawValue = Int + + /// + /// Default behavior. + /// Buzzer is enabled for all audio feedback including button presses and alerts. + case allEnabled // = 0 + + /// + /// Disabled. + /// All buzzer audio feedback is disabled. + case disabled // = 1 + + /// + /// Notifications Only. + /// Buzzer is enabled only for notifications and alerts, but not for button presses. + /// External notification config determines the specifics of the notification behavior. + case notificationsOnly // = 2 + + /// + /// Non-notification system buzzer tones only. + /// Buzzer is enabled only for non-notification tones such as button presses, startup, shutdown, but not for alerts. + case systemOnly // = 3 + case UNRECOGNIZED(Int) + + public init() { + self = .allEnabled + } + + public init?(rawValue: Int) { + switch rawValue { + case 0: self = .allEnabled + case 1: self = .disabled + case 2: self = .notificationsOnly + case 3: self = .systemOnly + default: self = .UNRECOGNIZED(rawValue) + } + } + + public var rawValue: Int { + switch self { + case .allEnabled: return 0 + case .disabled: return 1 + case .notificationsOnly: return 2 + case .systemOnly: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + public static let allCases: [Config.DeviceConfig.BuzzerMode] = [ + .allEnabled, + .disabled, + .notificationsOnly, + .systemOnly, + ] + + } + public init() {} } @@ -2063,6 +2129,7 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl 10: .standard(proto: "disable_triple_click"), 11: .same(proto: "tzdef"), 12: .standard(proto: "led_heartbeat_disabled"), + 13: .standard(proto: "buzzer_mode"), ] public mutating func decodeMessage(decoder: inout D) throws { @@ -2082,6 +2149,7 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl case 10: try { try decoder.decodeSingularBoolField(value: &self.disableTripleClick) }() case 11: try { try decoder.decodeSingularStringField(value: &self.tzdef) }() case 12: try { try decoder.decodeSingularBoolField(value: &self.ledHeartbeatDisabled) }() + case 13: try { try decoder.decodeSingularEnumField(value: &self.buzzerMode) }() default: break } } @@ -2121,6 +2189,9 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl if self.ledHeartbeatDisabled != false { try visitor.visitSingularBoolField(value: self.ledHeartbeatDisabled, fieldNumber: 12) } + if self.buzzerMode != .allEnabled { + try visitor.visitSingularEnumField(value: self.buzzerMode, fieldNumber: 13) + } try unknownFields.traverse(visitor: &visitor) } @@ -2136,6 +2207,7 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl if lhs.disableTripleClick != rhs.disableTripleClick {return false} if lhs.tzdef != rhs.tzdef {return false} if lhs.ledHeartbeatDisabled != rhs.ledHeartbeatDisabled {return false} + if lhs.buzzerMode != rhs.buzzerMode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -2169,6 +2241,15 @@ extension Config.DeviceConfig.RebroadcastMode: SwiftProtobuf._ProtoNameProviding ] } +extension Config.DeviceConfig.BuzzerMode: SwiftProtobuf._ProtoNameProviding { + public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "ALL_ENABLED"), + 1: .same(proto: "DISABLED"), + 2: .same(proto: "NOTIFICATIONS_ONLY"), + 3: .same(proto: "SYSTEM_ONLY"), + ] +} + extension Config.PositionConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = Config.protoMessageName + ".PositionConfig" public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ diff --git a/MeshtasticProtobufs/Sources/meshtastic/device_ui.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/device_ui.pb.swift index 637b20a8..9607abe1 100644 --- a/MeshtasticProtobufs/Sources/meshtastic/device_ui.pb.swift +++ b/MeshtasticProtobufs/Sources/meshtastic/device_ui.pb.swift @@ -141,6 +141,10 @@ public enum Language: SwiftProtobuf.Enum, Swift.CaseIterable { /// Ukrainian case ukrainian // = 16 + /// + /// Bulgarian + case bulgarian // = 17 + /// /// Simplified Chinese (experimental) case simplifiedChinese // = 30 @@ -173,6 +177,7 @@ public enum Language: SwiftProtobuf.Enum, Swift.CaseIterable { case 14: self = .norwegian case 15: self = .slovenian case 16: self = .ukrainian + case 17: self = .bulgarian case 30: self = .simplifiedChinese case 31: self = .traditionalChinese default: self = .UNRECOGNIZED(rawValue) @@ -198,6 +203,7 @@ public enum Language: SwiftProtobuf.Enum, Swift.CaseIterable { case .norwegian: return 14 case .slovenian: return 15 case .ukrainian: return 16 + case .bulgarian: return 17 case .simplifiedChinese: return 30 case .traditionalChinese: return 31 case .UNRECOGNIZED(let i): return i @@ -223,6 +229,7 @@ public enum Language: SwiftProtobuf.Enum, Swift.CaseIterable { .norwegian, .slovenian, .ukrainian, + .bulgarian, .simplifiedChinese, .traditionalChinese, ] @@ -502,6 +509,7 @@ extension Language: SwiftProtobuf._ProtoNameProviding { 14: .same(proto: "NORWEGIAN"), 15: .same(proto: "SLOVENIAN"), 16: .same(proto: "UKRAINIAN"), + 17: .same(proto: "BULGARIAN"), 30: .same(proto: "SIMPLIFIED_CHINESE"), 31: .same(proto: "TRADITIONAL_CHINESE"), ] diff --git a/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift index 407d395f..85981376 100644 --- a/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift +++ b/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift @@ -458,6 +458,18 @@ public enum HardwareModel: SwiftProtobuf.Enum, Swift.CaseIterable { /// Reserved ID for future and past use case qwantzTinyArms // = 101 + ///* + /// Lilygo T-Deck Pro + case tDeckPro // = 102 + + ///* + /// Lilygo TLora Pager + case tLoraPager // = 103 + + ///* + /// GAT562 Mesh Trial Tracker + case gat562MeshTrialTracker // = 104 + /// /// ------------------------------------------------------------------------------------------------------------------------------------------ /// 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. @@ -573,6 +585,9 @@ public enum HardwareModel: SwiftProtobuf.Enum, Swift.CaseIterable { case 99: self = .seeedWioTrackerL1 case 100: self = .seeedWioTrackerL1Eink case 101: self = .qwantzTinyArms + case 102: self = .tDeckPro + case 103: self = .tLoraPager + case 104: self = .gat562MeshTrialTracker case 255: self = .privateHw default: self = .UNRECOGNIZED(rawValue) } @@ -682,6 +697,9 @@ public enum HardwareModel: SwiftProtobuf.Enum, Swift.CaseIterable { case .seeedWioTrackerL1: return 99 case .seeedWioTrackerL1Eink: return 100 case .qwantzTinyArms: return 101 + case .tDeckPro: return 102 + case .tLoraPager: return 103 + case .gat562MeshTrialTracker: return 104 case .privateHw: return 255 case .UNRECOGNIZED(let i): return i } @@ -791,6 +809,9 @@ public enum HardwareModel: SwiftProtobuf.Enum, Swift.CaseIterable { .seeedWioTrackerL1, .seeedWioTrackerL1Eink, .qwantzTinyArms, + .tDeckPro, + .tLoraPager, + .gat562MeshTrialTracker, .privateHw, ] @@ -2991,12 +3012,30 @@ public struct ClientNotification: Sendable { set {payloadVariant = .keyVerificationFinal(newValue)} } + public var duplicatedPublicKey: DuplicatedPublicKey { + get { + if case .duplicatedPublicKey(let v)? = payloadVariant {return v} + return DuplicatedPublicKey() + } + set {payloadVariant = .duplicatedPublicKey(newValue)} + } + + public var lowEntropyKey: LowEntropyKey { + get { + if case .lowEntropyKey(let v)? = payloadVariant {return v} + return LowEntropyKey() + } + set {payloadVariant = .lowEntropyKey(newValue)} + } + public var unknownFields = SwiftProtobuf.UnknownStorage() public enum OneOf_PayloadVariant: Equatable, Sendable { case keyVerificationNumberInform(KeyVerificationNumberInform) case keyVerificationNumberRequest(KeyVerificationNumberRequest) case keyVerificationFinal(KeyVerificationFinal) + case duplicatedPublicKey(DuplicatedPublicKey) + case lowEntropyKey(LowEntropyKey) } @@ -3053,6 +3092,26 @@ public struct KeyVerificationFinal: Sendable { public init() {} } +public struct DuplicatedPublicKey: Sendable { + // SwiftProtobuf.Message conformance is added in an extension below. See the + // `Message` and `Message+*Additions` files in the SwiftProtobuf library for + // methods supported on all messages. + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} +} + +public struct LowEntropyKey: Sendable { + // SwiftProtobuf.Message conformance is added in an extension below. See the + // `Message` and `Message+*Additions` files in the SwiftProtobuf library for + // methods supported on all messages. + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} +} + /// /// Individual File info for the device public struct FileInfo: Sendable { @@ -3578,6 +3637,9 @@ extension HardwareModel: SwiftProtobuf._ProtoNameProviding { 99: .same(proto: "SEEED_WIO_TRACKER_L1"), 100: .same(proto: "SEEED_WIO_TRACKER_L1_EINK"), 101: .same(proto: "QWANTZ_TINY_ARMS"), + 102: .same(proto: "T_DECK_PRO"), + 103: .same(proto: "T_LORA_PAGER"), + 104: .same(proto: "GAT562_MESH_TRIAL_TRACKER"), 255: .same(proto: "PRIVATE_HW"), ] } @@ -5348,6 +5410,8 @@ extension ClientNotification: SwiftProtobuf.Message, SwiftProtobuf._MessageImple 11: .standard(proto: "key_verification_number_inform"), 12: .standard(proto: "key_verification_number_request"), 13: .standard(proto: "key_verification_final"), + 14: .standard(proto: "duplicated_public_key"), + 15: .standard(proto: "low_entropy_key"), ] public mutating func decodeMessage(decoder: inout D) throws { @@ -5399,6 +5463,32 @@ extension ClientNotification: SwiftProtobuf.Message, SwiftProtobuf._MessageImple self.payloadVariant = .keyVerificationFinal(v) } }() + case 14: try { + var v: DuplicatedPublicKey? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .duplicatedPublicKey(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .duplicatedPublicKey(v) + } + }() + case 15: try { + var v: LowEntropyKey? + var hadOneofValue = false + if let current = self.payloadVariant { + hadOneofValue = true + if case .lowEntropyKey(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.payloadVariant = .lowEntropyKey(v) + } + }() default: break } } @@ -5434,6 +5524,14 @@ extension ClientNotification: SwiftProtobuf.Message, SwiftProtobuf._MessageImple guard case .keyVerificationFinal(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 13) }() + case .duplicatedPublicKey?: try { + guard case .duplicatedPublicKey(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 14) + }() + case .lowEntropyKey?: try { + guard case .lowEntropyKey(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 15) + }() case nil: break } try unknownFields.traverse(visitor: &visitor) @@ -5582,6 +5680,44 @@ extension KeyVerificationFinal: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } } +extension DuplicatedPublicKey: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".DuplicatedPublicKey" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + public func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: DuplicatedPublicKey, rhs: DuplicatedPublicKey) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension LowEntropyKey: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".LowEntropyKey" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + public func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: LowEntropyKey, rhs: LowEntropyKey) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension FileInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".FileInfo" public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ diff --git a/protobufs b/protobufs index 816595c8..c758376d 160000 --- a/protobufs +++ b/protobufs @@ -1 +1 @@ -Subproject commit 816595c8bbdfc3b4388e11348ccd043294d58705 +Subproject commit c758376d04cf5d3d42de24f9388836a18bae9a76