Los desarrolladores de apps para iOS pueden usar las APIs de Home para administrar un router de borde Thread.
El GoogleBorderRouterDevice se implementa con dos rasgos de dispositivo principales:
ThreadNetworkCapabilitiesTrait,
que proporciona atributos de solo lectura para inspeccionar las funciones del router de borde, y
ThreadNetworkManagementTrait,
que controla los comandos del ciclo de vida de la red y el uso compartido de credenciales
con una clave precompartida efímera para el comisionado (ePSKc). Las políticas de acceso a Internet a nivel de estructura
se administran con el
ThreadNetworkSettingsTrait
rasgo.
Siempre verifica la compatibilidad de los atributos y los comandos de un dispositivo antes de usar cualquier función o intentar actualizar los atributos. Consulta Controla dispositivos en iOS para obtener más información.
| Tipo de dispositivo de las APIs de Home | Rasgos | App de ejemplo de Swift | Caso de uso |
|---|---|---|---|
|
Router de borde
|
Rasgos obligatorios google ThreadNetworkCapabilitiesTrait google ThreadNetworkManagementTrait |
Router de borde |
Obtén información básica sobre un dispositivo
El BasicInformation
rasgo incluye información como el nombre del proveedor, el ID del proveedor, el ID del producto,
el nombre del producto (incluida la información del modelo) y la versión de software de 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!
Inspecciona las capacidades del router de borde
Puedes examinar las capacidades de solo lectura de un router de borde (como la compatibilidad con ePSKc y la configuración de acceso a Internet) con el rasgo 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)")
}
}
Administra el uso compartido de credenciales de Thread (ePSKc)
El uso compartido de credenciales de Thread se logra con una clave precompartida efímera para el comisionado (ePSKc). El modo ePSKc genera una clave de acceso segura y temporal que los dispositivos externos o los comisionados pueden usar para obtener de forma segura el conjunto de datos de la red Thread.
Activa el modo 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
}
}
Desactiva el modo 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)")
}
}
Observa los eventos de desactivación de ePSKc
Los routers de borde Thread emiten eventos cuando finaliza una sesión de ePSKc (por ejemplo, porque se usó la clave, venció la sesión o se canceló de forma manual).
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)")
}
}
Administra la membresía de la red Thread
Puedes ordenar a un router de borde Thread que se una a una red Thread nueva proporcionando los TLV del conjunto de datos operativos activos o que abandone su red actual.
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)")
}
}
Configura el acceso a Internet a nivel de estructura
El rasgo ThreadNetworkSettings es un rasgo actualizable adjunto a una Structure (que representa una casa o un edificio). Permite a los desarrolladores configurar la política de acceso a Internet en toda la estructura para los routers de borde 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)")
}
}