Turbine a conectividade do dispositivo com o Wi-Fi Aware

Turbine a conectividade do dispositivo com o Wi-Fi Aware

Saiba como criar conexões de rede ponto a ponto com o Wi-Fi Aware. Também abordaremos como compartilhar vídeos em tempo real, transferir arquivos grandes e controlar acessórios com largura de banda aprimorada e latência menor. E você saberá como usar os frameworks DeviceDiscoveryUI, AccessorySetupKit e Network para usar o Wi-Fi Aware em seu app.

Capítulos
- 0:00 - Introdução
- 1:01 - Visão geral
- 7:46 - Emparelhar
- 15:05 - Conectar
- 19:01 - Otimizar
- 22:26 - Diretrizes
Recursos
Vídeos relacionados

WWDC24
- Meet AccessorySetupKit
Olá! Meu nome é Swetank. Sou engineer na equipe Wi-Fi. Hoje, apresentarei o framework Wi-Fi Aware e mostrarei como usá-lo para aprimorar as interações entre dispositivos nos seus apps. Antes, vou dar uma visão geral do Wi-Fi Aware. Depois, mostrarei como integrar o Wi-Fi Aware ao seu app.
Abordarei a descoberta e o emparelhamento seguros de dispositivos usando os frameworks DeviceDiscoveryUI e AccessorySetupKit. Falarei sobre como os dispositivos podem configurar conexões Wi-Fi Aware com o framework Network. Após a conexão, analisarei como monitorar e otimizar o desempenho das conexões Wi-Fi Aware. E falarei sobre próximas etapas importantes. Primeiro, uma visão geral. O Wi-Fi Aware permite a comunicação direta entre dispositivos. Enquanto modelos tradicionais usam roteadores ou servidores centrais, ele é ponto a ponto.
Essas conexões são dinâmicas e sob demanda. Dispositivos se encontram e formam links seguros no tempo de execução. Isso é ideal para ações locais breves, como compartilhar arquivos ou configurar um acessório. O Wi-Fi Aware opera com sua conexão Wi-Fi normal. Ou seja, os dispositivos permanecem conectados à internet e à rede local enquanto usam o Wi-Fi Aware. O Wi-Fi Aware é um padrão global mantido pela Wi-Fi Alliance. É multiplataforma, interoperável e pode ser adotado por qualquer fabricante de dispositivos. Com ele, você pode permitir novas experiências e que seus apps descubram e se conectem facilmente a dispositivos próximos. Exemplos incluem: Streaming de mídia, envio de arquivos em alta velocidade, controle de acessórios, compartilhamento de tela, tudo isso simultaneamente.
Conheça o Wi-Fi Aware, um novo framework que possibilita essas experiências no iPhone e no iPad. Com o framework Wi-Fi Aware, seu app pode se conectar a outros dispositivos Apple e de terceiros e a acessórios.
Ao usá-lo, as conexões são totalmente autenticadas e criptografadas na camada Wi-Fi, aceitam alta taxa de transferência e baixa latência e coexistem com conexões com outros dispositivos próximos ao mesmo tempo.
Para usar o Wi-Fi Aware, seu app só precisa lidar com dois fluxos de alto nível. O primeiro é emparelhar um dispositivo.
O emparelhamento é uma configuração única que gera confiança e facilita a comunicação segura. O segundo é conectar dispositivos emparelhados. O sistema protege a conexão entre os dispositivos, incluindo troca de chaves e criptografia de links, para que você não precise gerenciar protocolos de segurança. Após emparelhado, seu app pode se reconectar com segurança quando os dispositivos estiverem próximos e executando-o ativamente. Isso torna a conexão de volta com o dispositivo perfeita, rápida e segura. Vamos ver como configurar seu app para usar o Wi-Fi Aware. Começaremos falando de um conceito essencial do Wi-Fi Aware: serviços. Os serviços são usados para descobrir dispositivos e se conectar a eles. Pense nos serviços como uma funcionalidade que seu app fornece ou usa de outros dispositivos. Antes da declaração de serviços no seu app, vamos entender convenções importantes para serviços.
Um serviço é identificado pelo nome.
Os nomes de serviços devem ser exclusivos, usar apenas letras, números e traços e ter até 15 caracteres.
Há duas partes em um nome de serviço completo.
Um nome exclusivo, seguido por um protocolo, sendo tcp para serviços que usam TCP ou udp para serviços que usam outro protocolo.
Para evitar coincidências entre os nomes de serviço dos seus apps e os usados por outros apps, você pode registrá-los na IANA.
Vamos falar sobre funções de serviço. O Wi-Fi Aware permite duas possíveis funções para um serviço. A primeira é editor, em que seu app hospeda o serviço e atua como servidor, ouvindo as conexões de entrada de outros dispositivos.
A segunda é assinante, em que seu app usa o serviço e atua como cliente, procurando outros dispositivos para se conectar.
Seu app pode operar simultaneamente como editor e assinante, se necessário para seus casos de uso.
O Info.plist do seu app especifica os serviços que ele pretende usar. Para isso, adicione a chave WiFiAwareServices. É um dicionário onde as chaves são nomes de serviço e o valor correspondente é a configuração desse serviço. Neste exemplo, o app declara dois serviços: de arquivo e de drone.
Cada um tem um dicionário de propriedades de configuração.
Para tornar um serviço publicável, inclua a chave Publishable. E para torná-lo assinável, inclua a chave Subscribable. Nesse caso, o serviço de arquivo é declarado como publicável e assinável. Isso é comum ao criar casos de uso de app para app.
Por outro lado, o serviço de drone é apenas assinável, cenário comum ao desenvolver um app para se comunicar com um acessório. Seu app só poderá publicar ou assinar os serviços declarados no arquivo Info.plist.
Vamos examinar um código e ver como acessar recursos e serviços de dispositivos declarados no Info.plist.
Antes de um app usar o Wi-Fi Aware, ele deve verificar se é compatível com o dispositivo. Isso é feito verificando a propriedade supportedFeatures do WACapabilities.
Os serviços publicáveis definidos no Info.plist são disponibilizados por meio do WAPublishableService. Aqui, uma propriedade estática, fileService, é definida para acesso conveniente ao serviço posteriormente. Os serviços assináveis são acessados via WASubscribableService. Duas propriedades estáticas são definidas para referenciar fileService e droneService para uso posterior.
Agora que você sabe adicionar serviços Wi-Fi Aware ao seu app, vamos ver como emparelhar dispositivos Wi-Fi Aware. Vamos falar sobre como é o fluxo de emparelhamento de uma pessoa que usa seu app. Como falamos, seu app emparelhará dispositivos Wi-Fi Aware antes de usá-los. Ele pode acionar o emparelhamento chamando APIs para mostrar a interface de emparelhamento do sistema. Para os usuários do app, o emparelhamento segue um processo simples.
A pessoa precisará selecionar um dispositivo em uma lista de dispositivos próximos que correspondam aos parâmetros do seu app.
Ela autorizará o emparelhamento inserindo um código PIN fornecido pelo outro dispositivo.
O sistema concluirá o emparelhamento e avisará a pessoa quando tiver êxito. Isso disponibilizará o dispositivo para seu app. Depois disso, seu app poderá se conectar ao dispositivo sob demanda sem invocar o fluxo de emparelhamento.
Há dois frameworks de sistema para emparelhar dispositivos: DeviceDiscoveryUI e AccessorySetupKit.
O DeviceDiscoveryUI é usado para fazer conexões entre apps e de um app com outro dispositivo. Ele permite o emparelhamento com dispositivos Apple e de terceiros. O AccessorySetupKit permite aos fabricantes de acessórios incorporá-los rapidamente. Ele é recomendado para fabricantes de acessórios de hardware. Vamos falar mais sobre o DeviceDiscoveryUI.
Quem usa esse framework pressiona um botão na interface do app para adicionar ou selecionar um dispositivo. No lado do editor, seu app chama APIs para exibir a interface do anunciante, à esquerda. Em outro dispositivo, ele chama APIs para exibir a interface do seletor de dispositivos, à direita.
A interface do navegador encontra dispositivos correspondentes ao serviço Wi-Fi Aware e os exibe para a pessoa escolher. Se a pessoa selecionar um dispositivo não emparelhado, o sistema iniciará o emparelhamento.
Quando o emparelhamento é necessário, a solicitação recebida e um código PIN são exibidos no lado do editor e inseridos pelo assinante.
Após a confirmação do PIN, o sistema emparelha os dispositivos. Após a conclusão, seu app pode se conectar a outro dispositivo.
Agora que vimos o fluxo do DeviceDiscoveryUI, vamos examinar um código.
No lado do ouvinte, seu app criará um DevicePairingView passando a ele o serviço a ser anunciado.
No lado do navegador, ele criará um DevicePickerView passando a ele o serviço a ser descoberto. Ao escolher um dispositivo descoberto, o DeviceDiscoveryUI renderizará o endpoint de rede conectável para seu app. Se necessário, o DeviceDiscoveryUI fará o emparelhamento antes de fornecer o endpoint de rede.
Se você é fabricante de acessórios, o AccessorySetupKit é recomendado para emparelhar com seu app. Se o acessório usar vários transportes, como Bluetooth e Wi-Fi Aware, o AccessorySetupKit emparelhará e configurará os dois ao mesmo tempo. Vamos ver o fluxo de emparelhamento ao usar o AccessorySetupKit com o Wi-Fi Aware. Quem usa o AccessorySetupKit pressiona um botão no app para adicionar ou selecionar um dispositivo. Seu app preenche um descritor de descoberta, especificando o serviço e os filtros para descobrir dispositivos. E apresenta a interface do AccessorySetupKit.
Ele encontra os dispositivos correspondentes ao seu filtro de serviço e descoberta e os exibe na interface. A pessoa seleciona o dispositivo que deseja configurar.
Na configuração, ela insere um PIN para confirmar o emparelhamento do Wi-Fi Aware. O PIN é exibido para o editor e inserido pelo assinante.
O sistema faz o emparelhamento em nome do app.
Agora que vimos o fluxo do AccessorySetupKit, vamos examinar o código. Para emparelhar dispositivos Wi-Fi Aware com o AccessorySetupKit, crie um ASDiscoveryDescriptor com o nome de serviço e os filtros de propriedades de dispositivos, como modelo e fornecedor. Apresente a interface do AccessorySetupKit criando um ASAccessorySession e chamando showPicker nele. O sistema cuidará do processo de descoberta e emparelhamento. Um novo ASAccessory será retornado, que representa o dispositivo recém-emparelhado. Ele contém um ASAccessoryWiFiAwarePairedDeviceID, que é o ID do dispositivo emparelhado. Seu app pode usar esse ID para procurar o WAPairedDevice correspondente pelo framework Wi-Fi Aware. Você pode usar o dispositivo para iniciar uma conexão com o framework Network.
Saiba mais na sessão “Conhecer o AccessorySetupKit” da WWDC24. Agora que expliquei como emparelhar dispositivos, vamos ver como o app pode acessar a lista de dispositivos emparelhados.
O Wi-Fi Aware representa um dispositivo emparelhado como um struct WAPairedDevice. Obtenha a lista de dispositivos usando a API allDevices no WAPairedDevice. Acesse as propriedades do dispositivo, como fornecedor e nome do modelo, aprendidas no emparelhamento.
A API pode incluir todos os dispositivos ou os condizentes com um dado filtro.
Para obter os dispositivos correspondentes a Example Inc como nome de fornecedor, crie um filtro.
A lista de dispositivos emparelhados pode mudar a qualquer momento. Se um dispositivo for removido dos ajustes, seu app poderá ouvir essas alterações e atualizar a interface e outros estados de acordo. O framework fornece um modo fácil de fazer isso vendendo uma sequência assíncrona por meio do WaPairedDevice.allDevices.
As APIs discutidas abrangem todos os dispositivos emparelhados disponíveis para seu app, estejam eles acessíveis no momento ou não. Agora que vimos o primeiro fluxo de alto nível, emparelhamento, vamos focar no segundo, em que seu app estabelecerá conexões com dispositivos emparelhados. Antes de analisar o código, vamos entender o fluxo de alto nível para estabelecer uma conexão Wi-Fi Aware. Estabelecer uma conexão requer dois dispositivos. Um dispositivo publica o serviço e ouve as conexões de dispositivos emparelhados.
O outro dispositivo assina o serviço e procura dispositivos emparelhados para se conectar. Para poupar energia, ouvir e navegar devem se limitar à duração necessária para o seu caso de uso.
Quando o navegador descobre a combinação de serviço e dispositivo fornecida, informa endpoints de rede conectáveis ao app. Depois, seu app analisará os endpoints e estabelecerá conexões com um ou mais deles. O ouvinte recebe a solicitação de conexão e a encaminha para seu app, concluindo a conexão. Neste ponto, dados podem ser trocados.
Vamos explorar como usar o framework Network no app para estabelecer uma conexão Wi-Fi Aware. Antes de publicar ou assinar, seu app deve selecionar os dispositivos emparelhados de interesse. Aqui, o editor cria um filtro para dispositivos com nomes que começam com My Device.
O filtro de assinantes seleciona dispositivos com nomes de fornecedores que começam com Example Inc.
Os parâmetros necessários estão disponíveis para iniciar instâncias de ouvinte e navegador com o framework Network.
Para construir um NetworkListener, forneça o objeto de serviço e o filtro de dispositivo já criado.
Criado assim, o NetworkListener só aceitará conexões para o serviço especificado e dispositivos emparelhados que correspondam ao filtro fornecido.
Além dos parâmetros Wi-Fi Aware, seu app pode configurar parâmetros de rede e o gerenciador de atualizações de estado.
O NetworkBrowser é criado usando o filtro de serviço e dispositivo anterior.
Ele só descobrirá dispositivos emparelhados que estejam anunciando o serviço e correspondam ao filtro.
Depois de criar um ouvinte e um navegador, seu app agora pode estabelecer uma conexão. Para começar a aceitar conexões de entrada no ouvinte, invoque a operação run no objeto listener.
Iniciar o ouvinte torna seu app detectável para outros dispositivos.
Para iniciar a assinatura de serviços no navegador, invoque a operação run no objeto browser.
Iniciar o navegador descobre dispositivos próximos que oferecem o serviço. O navegador retornará os dispositivos descobertos como endpoints de rede para seu app.
Seu app analisará os endpoints descobertos e decidirá se o endpoint de interesse está presente.
Use a API NetworkConnection para iniciar conexões com o endpoint desejado.
Após a configuração da conexão, o ouvinte receberá um callback para a nova conexão, fornecendo-o ao seu app. Seu app agora pode trocar dados usando APIs do framework Network. Para poupar energia e recursos sem fio, pare o ouvinte e o navegador após todas as conexões necessárias serem feitas.
Abordei as etapas necessárias para estabelecer uma conexão Wi-Fi Aware. Vamos ver como otimizar o desempenho da conexão para a melhor experiência possível com o app. Para isso, você deve equilibrar taxa de transferência, latência e consumo de energia. Na maioria dos casos, o sistema aplicará padrões razoáveis. Mas, se necessário, seu app pode ajustar certos parâmetros de conexão.
Um é o modo de desempenho do Wi-Fi Aware, que influencia o ciclo de trabalho do Wi-Fi Aware.
O outro é a classe de serviço de tráfego, que define a prioridade para a transmissão de pacotes. O padrão é melhor esforço, mas você pode escolher voz ou vídeo interativo para menor latência.
Se tiver dados de baixa prioridade, use a classe em segundo plano para não interferir em outro tráfego.
O modo em massa é usado com a classe melhor esforço ou em segundo plano. Essa combinação resulta em menor consumo de energia, mas maior latência.
Em tempo real é usado com a classe de serviço voz ou vídeo interativo. Isso proporciona menor latência, mas maior consumo de energia. Ao escolher o modo em tempo real, considere se é necessário no seu caso, pois pode afetar negativamente o consumo de bateria. Além de oferecer configurações ajustáveis para o desempenho da conexão, o framework Wi-Fi Aware fornece um relatório desempenho sob demanda de cada conexão de rede. Esse relatório inclui métricas sobre intensidade do sinal, taxa de transferência e latência. Use isso para ajustar o desempenho do app. Como a intensidade da conexão Wi-Fi, a interferência ambiental e os recursos de dispositivos podem variar bastante, teste o desempenho do seu app em ambientes Wi-Fi movimentados. Além disso, incorpore comentários de conexão de protocolos de rede, como TCP, no seu app.
Vamos analisar algum código e ver como você pode usar os parâmetros ajustáveis. As conexões Wi-Fi Aware têm como padrão o modo de desempenho em massa e a classe de serviço melhor esforço. Se a criação de perfil sugerir que você se beneficiará de outra configuração, será possível definir os parâmetros no editor e a instância de conexão no assinante para configurar o modo de desempenho e a classe de serviço.
Aqui, o editor é configurado para usar o modo de desempenho em tempo real e a classe de serviço vídeo interativo.
No lado do assinante, a mesma configuração é necessária no objeto NetworkConnection criado pelo seu app.
Para monitorar a conexão Wi-Fi Aware do seu app, acesse o caminho atual e leia o relatório de desempenho. Seu app pode executar ações com base nesse relatório e refinar a experiência geral do usuário.
Agora que abordei tudo que é necessário para criar um app usando o Wi-Fi Aware, mal posso esperar para ver o que você vai inventar. Antes de encerrar, vamos falar sobre as próximas etapas importantes. Ao desenvolver um dispositivo compatível com o Wi-Fi Aware, veja as diretrizes de design de acessórios para garantir a interoperabilidade com dispositivos Apple. O documento de diretrizes está disponível no site Apple Developer. Seguindo o guia, seu dispositivo pode descobrir e emparelhar com dispositivos Apple de modo confiável, manter uma boa segurança e maximizar o desempenho da conexão.
O guia é o melhor recurso para criar experiências Wi-Fi Aware consistentes e de alta qualidade.
Consulte a documentação do framework Wi-Fi Aware para obter mais detalhes. Há um app de exemplo que mostra como criar um app usando o Wi-Fi Aware e como configurações de desempenho afetam nosso comportamento.
Ao criar um dispositivo Wi-Fi Aware, o guia de interoperabilidade pode ajudar a criar a melhor experiência possível para seus usuários.
Agradeço por assistir.

import WiFiAware

// Check if Wi-Fi Aware is supported on your device
guard WACapabilities.supportedFeatures.contains(.wifiAware) else { return }

// Publishable service declared in Info.plist
extension WAPublishableService {
    public static var fileService: WAPublishableService {
        allServices["_file-service._tcp"]!
    }
}

// Subscribable services declared in Info.plist
extension WASubscribableService {
    public static var fileService: WASubscribableService {
        allServices["_file-service._tcp"]!
    }
    public static var droneService: WASubscribableService {
        allServices["_drone-service._udp"]!
    }
}

10:33 - Pair with DeviceDiscoveryUI

import DeviceDiscoveryUI
import WiFiAware
import SwiftUI

// Listener (Publisher) Device
// Invoke Listener UI
DevicePairingView(.wifiAware(.connecting(to: .fileService, from: .selected([])))) {
    // Provide a view to display to user before launching System UI
} fallback: {
    // Provide a view in case of error
}

// Browser (Subscriber) Device
// Invoke Browser UI
DevicePicker(.wifiAware(.connecting(to: .selected([]), from: .fileService))) { endpoint in
    // Process the paired network endpoint
} label: {
    // Provide a view to display to user before launching System UI
} fallback: {
    // Provide a view in case of error
}

12:29 - Pair with AccessorySetupKit

import AccessorySetupKit

// Configure ASDiscoveryDescriptor (Subscriber)
let descriptor = ASDiscoveryDescriptor()
descriptor.wifiAwareServiceName = "_drone-service._udp"
descriptor.wifiAwareModelNameMatch = .init(string: "Example Model")
descriptor.wifiAwareVendorNameMatch = .init(string: "Example Inc", compareOptions: .literal)
let item = ASPickerDisplayItem(name: "My Drone",
                               productImage: UIImage(named: "DroneProductImage")!,
                               descriptor: descriptor)

// Create and activate session
let session = ASAccessorySession()
session.activate(on: sessionQueue) { event in
    // Closure will execute when device is added with event: .accessoryAdded
    // ASAccessoryWiFiAwarePairedDeviceID can be used to lookup a WAPairedDevice
}
// Present Picker UI
session.showPicker(for: [item]) { error in
    // Handle error
}

13:51 - Access paired devices

import Foundation
import WiFiAware

// WAPairedDevice
var device: WAPairedDevice // Get using WAPairedDevice.allDevices

// Access WAPairedDevice properties
let pairingName = device.pairingInfo?.pairingName
let vendorName = device.pairingInfo?.vendorName
let modelName = device.pairingInfo?.modelName

// Create a filter to select devices of interest
let filter = #Predicate<WAPairedDevice> {
    $0.pairingInfo?.vendorName.starts(with: "Example Inc") ?? false
}

// Get all paired devices, matching the filter, at the current moment
// A new snapshot of all paired devices each time a device is added, changed, or removed
for try await devices in WAPairedDevice.allDevices(matching: filter) {
    // Process new snapshot of all paired devices
}

16:23 - Filter paired devices

import Foundation
import WiFiAware

// Listener (Publisher) Device
// Specify the paired devices of interest for the use case
let deviceFilter = #Predicate<WAPairedDevice> {
    $0.name?.starts(with: "My Device") ?? false
}

// Browser (Subscriber) Device
// Specify the paired devices of interest for the use case
let deviceFilter = #Predicate<WAPairedDevice> {
    $0.pairingInfo?.vendorName.starts(with: "Example Inc") ?? false
}

16:54 - Create listener and browser

import WiFiAware
import Network

// Listener (Publisher) Device: Construct a NetworkListener
let listener = try NetworkListener(for:
        .wifiAware(.connecting(to: .fileService, from: .matching(deviceFilter))),
    using: .parameters {
        TLS()
    })
    .onStateUpdate { listener, state in
        // Process state update
    }

// Browser (Subscriber) Device: Construct a NetworkBrowser
let browser = NetworkBrowser(for:
        .wifiAware(.connecting(to: .matching(deviceFilter), from: .fileService))
    )
    .onStateUpdate { browser, state in
        // Process state update
    }

17:44 - Establish a connection

// Listener (Publisher) Device: Start NetworkListener
try await listener.run { connection in  // Radio resources in use
    // Closure executes for each incoming connection
    connection.onStateUpdate { connection, state in
        // Process state update
    }
}

// Browser (Subscriber) Device: Start NetworkBrowser
let endpoint = try await browser.run { waEndpoints in // Radio resources in use
        // Review endpoints, decide whether to return or skip
        if let endpoint = self.endpoint(in: waEndpoints) { return .finish(endpoint) }
        else { return .continue }
    }
// Create the connection
let connection = NetworkConnection(to: endpoint, using: .parameters {
        TLS()
    })
    .onStateUpdate { connection, state in
        // Process state update
    }

21:11 - Tune performance

// Listener (Publisher) Device
// Configure .realtime + .interactiveVideo on NetworkListener
let listener = try NetworkListener(for:
        .wifiAware(.connecting(to: .fileService, from: .matching(deviceFilter))),
    using: .parameters {
        TLS()
    }
    .wifiAware { $0.performanceMode = .realtime }
    .serviceClass(.interactiveVideo))

// Browser (Subscriber) Device
// Configure .realtime + .interactiveVideo on NetworkConnection
let connection = NetworkConnection(to: endpoint, using: .parameters {
        TLS()
    }
    .wifiAware { $0.performanceMode = .realtime }
    .serviceClass(.interactiveVideo))

// Listener (Publisher) Device & Browser (Subscriber) Device
// Read performance report
let performanceReport = try await connection.currentPath?.wifiAware?.performance

- 0:00 - Introdução
- Saiba como usar o Wi-Fi Aware no iOS e no iPadOS para criar conexões de rede ponto a ponto com baixa latência e alta taxa de transferência.
- 1:01 - Visão geral
- O Wi-Fi Aware é um padrão que permite a comunicação direta entre dispositivos, sem a necessidade de roteadores ou servidores centrais. Ele funciona em paralelo com conexões Wi‑Fi tradicionais, permitindo que dispositivos se descubram e se conectem de forma segura e dinâmica para criar experiências locais e efêmeras, como compartilhamento de arquivos, streaming de mídia, controle de acessórios e compartilhamento de tela. O Wi‑Fi Aware é multiplataforma e interoperável, com conexões totalmente autenticadas e criptografadas. Os apps podem definir serviços, especificar funções como editor, assinante ou ambos e emparelhar dispositivos para reconexões rápidas e contínuas sempre que estiverem próximos.
- 7:46 - Emparelhar
- Os dispositivos podem ser emparelhados usando o framework DeviceDiscoveryUI ou AccessorySetupKit. O DeviceDiscoveryUI é indicado para emparelhamento entre apps e é compatível com dispositivos Apple e de terceiros. Já o AccessorySetupKit é adequado para emparelhamento entre o app e os acessórios. Após o emparelhamento, ambos os frameworks permitem que os apps acessem e gerenciem a lista de dispositivos emparelhados, recuperem suas propriedades e monitorem alterações no status de emparelhamento, possibilitando a atualização da interface e do estado do app, conforme necessário.
- 15:05 - Conectar
- Quando estão emparelhados, os dispositivos podem se conectar uns aos outros. Um dispositivo tem a função de editor e o outro, de assinante. O editor filtra dispositivos específicos e começa a escutar, enquanto o assinante filtra e começa a navegar. Depois que o assinante encontra o editor, ele fornece pontos de extremidade para o app, que então estabelece conexões. O ouvinte recebe e encaminha essas solicitações de conexão, possibilitando a troca de dados.
- 19:01 - Otimizar
- Para otimizar o desempenho de conexão de um app, o framework Wi‑Fi Aware permite que os desenvolvedores ajustem determinados parâmetros. Ele oferece dois modos principais de desempenho: em massa e em tempo real. O modo em massa é mais eficiente em termos de energia, mas apresenta maior latência, enquanto o modo em tempo real oferece menor latência com maior consumo de energia. Os desenvolvedores também podem definir a classe de serviço de tráfego para priorizar a transmissão de pacotes, com opções como melhor esforço, vídeo ou voz interativos e serviço em segundo plano. O framework oferece relatórios de desempenho sob demanda, com métricas de intensidade de sinal, taxa de transferência e latência, que os desenvolvedores podem usar para ajustar o desempenho do app com base em testes no mundo real e fatores ambientais.
- 22:26 - Diretrizes
- Fabricantes de hardware que desenvolvem dispositivos compatíveis com Wi‑Fi Aware podem consultar as Diretrizes de Design para Acessórios da Apple, disponíveis no site para desenvolvedores, para garantir interoperabilidade, segurança e otimização de desempenho. Esse guia, junto com a documentação do framework e o app de exemplo, oferece recursos essenciais para a criação de experiências de uso de alta qualidade.

Capítulos

Recursos

Vídeos relacionados

WWDC24