Gli sviluppatori di app per iOS possono utilizzare le API Home per gestire un Thread Border Router (TBR).
Il GoogleBorderRouterDevice viene implementato utilizzando due tratti di dispositivo principali:
ThreadNetworkCapabilitiesTrait,
che fornisce attributi di sola lettura per esaminare le funzionalità border router,
e ThreadNetworkManagementTrait,
che gestisce i comandi del ciclo di vita della rete e la condivisione delle credenziali
utilizzando una chiave precondivisa temporanea per il commissario (ePSKc). Le policy di accesso a internet a livello di struttura
vengono gestite utilizzando il
ThreadNetworkSettingsTrait
tratto.
Prima di utilizzare qualsiasi funzionalità o tentare di aggiornare gli attributi, controlla sempre il supporto degli attributi e dei comandi per un dispositivo. Per ulteriori informazioni, consulta Controllare i dispositivi su iOS.
| Tipo di dispositivo API Home | Tratti | App di esempio Swift | Caso d'uso |
|---|---|---|---|
|
Router di confine
|
Tratti obbligatori google ThreadNetworkCapabilitiesTrait google ThreadNetworkManagementTrait |
Router di confine |
Recuperare informazioni di base su un dispositivo
Implementato nell'app di esempio per iOS
Il BasicInformation
tratto include informazioni come il nome del fornitore, l'ID fornitore, l'ID prodotto,
nome del prodotto (incluse le informazioni sul modello) e la versione software di un dispositivo:
let vendorName = basicInfoTrait.attributes.vendorName! let vendorID = basicInfoTrait.attributes.vendorID! let productID = basicInfoTrait.attributes.productID! let productName = basicInfoTrait.attributes.productName! let softwareVersion = basicInfoTrait.attributes.softwareVersion!
Esaminare le funzionalità del router di confine
Puoi esaminare le funzionalità di sola lettura di un border router's (ad esempio
il supporto ePSKc e la configurazione dell'impostazione di accesso a internet) utilizzando il
ThreadNetworkCapabilitiesTrait tratto.
func checkBorderRouterCapabilities(device: HomeDevice) async {
// Filter for GoogleBorderRouterDevice device type
guard let gtbrDevice = device.type(Google.GoogleBorderRouterDevice.self) else {
print("Device is not a Google border router.")
return
}
// Retrieve the ThreadNetworkCapabilitiesTrait
guard let capabilitiesTrait = gtbrDevice.traits(Google.ThreadNetworkCapabilitiesTrait.self) else {
print("ThreadNetworkCapabilitiesTrait not found on device.")
return
}
do {
let isEpskcSupported = try await capabilitiesTrait.epskcSupported.read()
let internetAccessOption = try await capabilitiesTrait.internetAccessOption.read()
let isIasSupported = internetAccessOption != .none
print("ePSKc Supported: \(isEpskcSupported)")
print("Internet Access Setting Supported: \(isIasSupported)")
} catch {
print("Failed to read capabilities: \(error)")
}
}
Gestire la condivisione delle credenziali Thread (ePSKc)
La condivisione delle credenziali Thread viene eseguita utilizzando una chiave precondivisa temporanea per il commissario (ePSKc). La modalità ePSKc genera una passkey temporanea e sicura che i dispositivi o i commissari esterni possono utilizzare per ottenere in modo sicuro il set di dati della rete Thread.
Attivare la modalità ePSKc
func startEpskcSession(device: HomeDevice, durationSeconds: Int16) async -> Google.ThreadNetworkManagementTrait.ActivateEpskcModeResponse? {
guard let gtbrDevice = device.type(Google.GoogleBorderRouterDevice.self),
let mgmtTrait = gtbrDevice.traits(Google.ThreadNetworkManagementTrait.self) else {
print("ThreadNetworkManagementTrait not found.")
return nil
}
do {
var request = Google.ThreadNetworkManagementTrait.ActivateEpskcModeRequest()
request.requestedDurationSeconds = durationSeconds
let response = try await mgmtTrait.activateEpskcMode(request)
print("ePSKc Session Activated!")
print("Status: \(response.status)")
print("Ephemeral PSKc: \(response.epskc)")
print("Valid Duration (s): \(response.validDurationSeconds)")
return response
} catch {
print("Failed to activate ePSKc mode: \(error)")
return nil
}
}
Disattivare la modalità ePSKc
func stopEpskcSession(device: HomeDevice) async {
guard let gtbrDevice = device.type(Google.GoogleBorderRouterDevice.self),
let mgmtTrait = gtbrDevice.traits(Google.ThreadNetworkManagementTrait.self) else {
return
}
do {
try await mgmtTrait.deactivateEpskcMode(Google.ThreadNetworkManagementTrait.DeactivateEpskcModeRequest())
print("ePSKc mode deactivated.")
} catch {
print("Failed to deactivate ePSKc mode: \(error)")
}
}
Osservare gli eventi di disattivazione ePSKc
TBRs emettono eventi quando termina una sessione ePSKc (ad esempio, perché la chiave è stata utilizzata, la sessione è scaduta o è stata annullata manualmente).
func observeEpskcEvents(device: HomeDevice) async {
guard let gtbrDevice = device.type(Google.GoogleBorderRouterDevice.self),
let mgmtTrait = gtbrDevice.traits(Google.ThreadNetworkManagementTrait.self) else {
return
}
do {
for try await event in mgmtTrait.epskcModeDeactivatedEvent.stream() {
print("ePSKc Session Ended. Reason: \(event.reason)")
switch event.reason {
case .keyUsed:
print("Key was successfully used to commission a device.")
case .expired:
print("Session timed out before the key was used.")
case .cancelled:
print("Session was manually cancelled.")
@unknown default:
print("Unknown deactivation reason.")
}
}
} catch {
print("Error streaming ePSKc events: \(error)")
}
}
Gestire l'appartenenza alla rete Thread
Puoi comandare a un TBR di unirsi a una nuova rete Thread fornendo i TLV del set di dati operativi attivi oppure di lasciare la rete attuale.
func joinNetwork(device: HomeDevice, datasetTlvs: Data) async {
guard let gtbrDevice = device.type(Google.GoogleBorderRouterDevice.self),
let mgmtTrait = gtbrDevice.traits(Google.ThreadNetworkManagementTrait.self) else {
return
}
do {
var request = Google.ThreadNetworkManagementTrait.JoinNetworkRequest()
request.operationalDatasetTlvs = datasetTlvs
let response = try await mgmtTrait.joinNetwork(request)
print("Join network command sent. Status: \(response.status)")
} catch {
print("Join network failed: \(error)")
}
}
func leaveNetwork(device: HomeDevice) async {
guard let gtbrDevice = device.type(Google.GoogleBorderRouterDevice.self),
let mgmtTrait = gtbrDevice.traits(Google.ThreadNetworkManagementTrait.self) else {
return
}
do {
try await mgmtTrait.leaveNetwork(Google.ThreadNetworkManagementTrait.LeaveNetworkRequest())
print("Leave network command sent successfully.")
} catch {
print("Leave network failed: \(error)")
}
}
Configurare l'accesso a internet a livello di struttura
Il tratto ThreadNetworkSettings è un tratto aggiornabile collegato a una Structure (che rappresenta una casa o un edificio). Consente agli sviluppatori di configurare
la policy di accesso a internet a livello di struttura per i TBRs.
func updateStructureInternetAccess(structure: Structure, enableInternetAccess: Bool) async {
guard let settingsTrait = structure.traits(Google.ThreadNetworkSettingsTrait.self) else {
print("ThreadNetworkSettingsTrait not found on structure.")
return
}
let option: Google.ThreadNetworkSettingsTrait.InternetAccessOption = enableInternetAccess ? .internetAccessOptionAll : .internetAccessOptionNone
do {
try await settingsTrait.update { mutator in
mutator.internetAccessOption = option
}
print("Successfully updated Thread internet access policy.")
} catch {
print("Failed to update Thread internet access policy: \(error)")
}
}