Gli sviluppatori di app per iOS possono utilizzare le API Home per gestire un router di confine Thread.
Il GoogleBorderRouterDevice viene implementato utilizzando due tratti di dispositivo principali:
ThreadNetworkCapabilitiesTrait,
che fornisce attributi di sola lettura per esaminare le funzionalità del router di confine, e
ThreadNetworkManagementTrait,
che gestisce i comandi del ciclo di vita della rete e la condivisione delle credenziali
utilizzando una chiave precondivisa temporanea per il Commissioner (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
Il BasicInformation
tratto include informazioni come il nome del fornitore, l'ID fornitore, l'ID prodotto,
il nome del prodotto (incluse le informazioni sul modello) e la versione del software per 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 router di confine (ad esempio il supporto ePSKc e la configurazione dell'impostazione di accesso a internet) utilizzando il tratto ThreadNetworkCapabilitiesTrait.
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 Commissioner (ePSKc). La modalità ePSKc genera una passkey temporanea e sicura che i dispositivi esterni o i Commissioner 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
I router di confine Thread emettono eventi quando una sessione ePSKc termina (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 router di confine Thread di unirsi a una nuova rete Thread fornendo i TLV del set di dati operativi attivi oppure di lasciare la rete corrente.
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 router di confine Thread.
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)")
}
}