meshtastic/Meshtastic-Apple
1
0
Fork 0
mirror of https://github.com/meshtastic/Meshtastic-Apple.git synced 2026-04-20 22:13:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge remote-tracking branch 'refs/remotes/origin/2.6.6'

Browse source
This commit is contained in:
Garth Vander Houwen 2025-06-15 19:24:01 -07:00
commit b0c5b57424
4 changed files with 346 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

121
MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift
View file

@ -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<D: SwiftProtobuf.Decoder>(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<V: SwiftProtobuf.Visitor>(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<D: SwiftProtobuf.Decoder>(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
}

81
MeshtasticProtobufs/Sources/meshtastic/config.pb.swift
View file

@ -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<D: SwiftProtobuf.Decoder>(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 = [

8
MeshtasticProtobufs/Sources/meshtastic/device_ui.pb.swift
View file

@ -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"),
]

136
MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift
View file

@ -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<D: SwiftProtobuf.Decoder>(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<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
// Load everything into unknown fields
while try decoder.nextFieldNumber() != nil {}
}
public func traverse<V: SwiftProtobuf.Visitor>(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<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
// Load everything into unknown fields
while try decoder.nextFieldNumber() != nil {}
}
public func traverse<V: SwiftProtobuf.Visitor>(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 = [