Boostez la connectivité des appareils avec Wi-Fi Aware

Boostez la connectivité des appareils avec Wi-Fi Aware

Découvrez comment créer des connexions réseau peer-to-peer avec Wi-Fi Aware. Nous verrons également comment partager des vidéos en temps réel, transférer des fichiers volumineux et contrôler les accessoires avec une bande passante améliorée et une latence plus faible. Vous apprendrez également à utiliser DeviceDiscoveryUI, AccessorySetupKit et le framework Network pour intégrer Wi-Fi Aware dans votre app.

Chapitres
- 0:00 - Introduction
- 1:01 - Aperçu
- 7:46 - Associer
- 15:05 - Connecter
- 19:01 - Optimiser
- 22:26 - Directives
Ressources
Vidéos connexes

WWDC24
- Meet AccessorySetupKit
Bonjour, je m’appelle Swetank. Je suis ingénieur au sein de l’équipe Wi-Fi. Aujourd’hui, je vais vous présenter le framework Wi-Fi Aware et montrer comment l’utiliser pour booster les interactions entre les appareils dans vos apps. D’abord, je poserai les bases avec un bref aperçu de Wi-Fi Aware. Puis, j’expliquerai comment intégrer cette fonction dans votre app.
J’aborderai ensuite la découverte et le jumelage sécurisés d’appareils avec les frameworks DeviceDiscoveryUI et AccessorySetupKit. Après le jumelage, je couvrirai comment un appareil peut configurer une connexion Wi-Fi Aware avec le framework Network. Une fois connecté, je verrai comment surveiller et optimiser les performances des connexions Wi-Fi Aware. Enfin, je parlerai de certaines prochaines étapes clés. Commençons par un aperçu. Wi-Fi Aware permet une communication directe entre les appareils. Contrairement aux modèles traditionnels qui utilisent des routeurs ou des serveurs centraux, la communication est réellement P2P.
Ces connexions sont dynamiques et à la demande. Les appareils peuvent se trouver mutuellement et établir des liens sécurisés à l’exécution. Idéal pour les expériences éphémères locales comme le partage de fichiers ou la configuration d’un accessoire. Wi-Fi Aware agit aux côtés de votre connexion Wi-Fi habituelle. Autrement dit, les appareils restent connectés à Internet et à votre réseau local tout en utilisant Wi-Fi Aware. Wi-Fi Aware est une norme mondiale gérée par la Wi-Fi Alliance. Il est multiplateforme, interopérable et peut être adopté par n’importe quel fabricant d’appareils. Wi-Fi Aware élargit vos horizons et permet à vos apps de détecter les appareils à proximité et de s’y connecter facilement. Citons quelques exemples : streaming multimédia, transfert de fichiers à grande vitesse, contrôle des accessoires et partage d’écran, tout cela en simultané si nécessaire.
Je vous présente Wi-Fi Aware, un nouveau framework qui offre ces expériences sur iPhone et iPad. Wi-Fi Aware permet à votre app de se connecter à d’autres appareils Apple à des appareils tiers, voire à des accessoires.
Lorsque vous utilisez Wi-Fi Aware, vos connexions sont authentifiées et chiffrées au niveau de la couche Wi-Fi, assurent un débit élevé et une faible latence, et coexistent avec des connexions simultanées à des appareils à proximité.
Pour utiliser Wi-Fi Aware, votre app doit gérer deux flux de haut niveau. Le premier consiste à jumeler un appareil.
Ce processus unique permet d’établir la confiance tout en sécurisant la communication. Le deuxième flux consiste à connecter des appareils jumelés. Le système sécurise automatiquement la connexion entre les appareils, y compris l’échange de clés et le chiffrement des liens. Vous n’avez à gérer aucun protocole de sécurité. Une app jumelée peut se reconnecter en toute sécurité dès que les appareils sont à proximité immédiate et qu’ils exécutent activement l’application. La reconnexion à l’appareil est ainsi transparente, rapide et sécurisée. Voyons comment configurer votre app pour utiliser Wi-Fi Aware. Parlons d’abord d’un concept central pour Wi-Fi Aware : les services. Les services sont utilisés pour détecter les appareils et s’y connecter. Considérez-les comme des fonctionnalités que l’app fournit ou consomme à partir d’autres appareils. Avant de déclarer des services dans votre app, découvrons quelques conventions clés les concernant.
Un service est identifié par son nom.
Un nom de service doit être unique, inclure seulement des lettres, des chiffres ou des tirets, et ne pas dépasser 15 caractères.
Un nom de service complet comporte deux parties.
Un nom unique, suivi d’un protocole, qui peut être tcp pour les services utilisant TCP ou udp pour ceux utilisant un autre protocole.
Pour éviter les conflits entre les noms de services de vos apps et ceux des autres apps, vous pouvez enregistrer les vôtres auprès de l’IANA.
Passons aux rôles de service. Wi-Fi Aware permet deux rôles possibles pour un service donné. Le premier est Éditeur, lorsque l’app héberge le service et agit comme un serveur, à l’écoute des connexions entrantes provenant d’autres appareils.
Le second est Abonné, lorsque l’app utilise le service et agit en tant que client, en recherchant d’autres appareils auxquels se connecter.
Votre application peut fonctionner simultanément en tant qu’éditeur et abonné si vos cas d’utilisation l’exigent.
Le fichier Info.plist de votre app spécifie les services qu’elle prévoit d’utiliser. Pour cela, ajoutez la clé WiFiAwareServices. Il s’agit d’un dictionnaire où les clés sont des noms de service, et la valeur correspondante la configuration de ce service. Dans cet exemple, l’app déclare deux services : le service de fichiers et le service de drone.
Chaque service a un dictionnaire de propriétés de configuration.
Pour qu’un service soit publiable, incluez la clé Publishable. Pour qu’un service permette l’abonnement, incluez la clé Subscribable. Dans ce cas, le service de fichiers est déclaré comme Publishable et Subscribable. C’est courant lors de la création de cas d’utilisation entre apps.
Le service de drone ne permet que l’abonnement, ce qui est courant avec les apps développées pour communiquer avec un accessoire. N’oubliez pas que votre app ne pourra publier des services ou s’y abonner que s’ils sont déclarés dans le fichier Info.plist. Passons maintenant au code et voyons comment accéder aux fonctionnalités et services déclarés dans le fichier Info.plist de l’appareil.
Avant qu’une app n’utilise Wi-Fi Aware, elle doit vérifier que l’appareil le prend en charge. Pour ce faire, vérifiez la propriété supportedFeatures de WACapabilities.
Les services publiables définis dans le fichier Info.plist sont mis à disposition via WAPublishableService. Dans cet exemple, une propriété statique, fileService, est définie pour accéder facilement au service ultérieurement. Les services permettant l’abonnement sont accessibles via WASubscribableService. Deux propriétés statiques sont définies pour faire référence à fileService et droneService pour une utilisation ultérieure.
Maintenant que vous savez ajouter des services Wi-Fi Aware à une app, voyons comment jumeler des appareils Wi-Fi Aware. Voyons à quoi ressemble le processus de jumelage pour une personne utilisant votre app. Pour rappel, votre app doit jumeler les appareils Wi-Fi Aware avant de les utiliser. Votre app peut déclencher le flux de jumelage en appelant des API pour afficher l’interface utilisateur de jumelage du système. Pour la personne qui utilise votre app, le jumelage suit un processus simple.
D’abord, elle sélectionne un appareil dans une liste d’appareils à proximité correspondant aux paramètres fournis par votre app.
Ensuite, elle autorise le jumelage en saisissant un code PIN fourni par l’autre appareil.
Enfin, le système termine le jumelage et informe cette personne lorsqu’il aboutit. L’appareil est désormais disponible pour votre app. Une fois disponible, votre app peut établir des connexions à cet appareil à la demande sans avoir à recommencer le jumelage.
Deux frameworks système permettent le jumelage des appareils : DeviceDiscoveryUI et AccessorySetupKit.
DeviceDiscoveryUI permet d’établir des connexions entre les apps et d’une app à un autre appareil. Il prend en charge le jumelage avec des appareils Apple et tiers. AccessorySetupKit permet aux fabricants d’accessoires d’intégrer rapidement leurs accessoires. C’est le framework recommandé pour les fabricants d’accessoires matériels. Parlons de DeviceDiscoveryUI plus en détail.
Un utilisateur de DeviceDiscoveryUI commencerait par appuyer sur un bouton dans l’UI de votre app pour ajouter ou sélectionner un appareil. Du côté de l’éditeur, l’app appelle des API pour présenter l’UI de l’annonceur, comme on le voit à gauche. Sur un autre appareil, l’app appelle des API pour présenter l’UI du sélecteur d’appareil, comme on le voit à droite.
l’UI du navigateur détecte les appareils à proximité qui correspondent à votre service Wi-Fi Aware et les présente à l’utilisateur pour qu’il puisse choisir. S’il sélectionne un appareil non jumelé, le système lance automatiquement le processus de jumelage.
Lorsque le jumelage est nécessaire, la requête entrante et un code PIN s’affichent du côté de l’éditeur et sont saisis du côté de l’abonné.
Une fois que l’utilisateur a confirmé le PIN, le système jumelle les appareils. Une fois l’opération terminée, l’app peut établir une connexion avec l’autre appareil.
Maintenant que nous avons vu le flux DeviceDiscoveryUI, examinons le code.
Du côté de l’écouteur, l’app crée une vue DevicePairing en lui transmettant le service à annoncer.
Du côté du navigateur, l’app crée une vue DevicePicker en lui transmettant le service à détecter. Lorsque vous touchez un appareil détecté, DeviceDiscoveryUI affiche le point de terminaison réseau connectable à votre app. Si nécessaire, DeviceDiscoveryUI effectue le jumelage avant de fournir le point de terminaison réseau.
Si vous êtes fabricant d’accessoires, AccessorySetupKit est recommandé pour le jumelage avec votre app. Si votre accessoire utilise plusieurs modes de transport, tels que Bluetooth et Wi-Fi Aware, AccessorySetupKit effectue le jumelage et la configuration en même temps. Examinons le flux de jumelage lors de l’utilisation d’AccessorySetupKit avec Wi-Fi Aware. Un utilisateur d’AccessorySetupKit commencerait par appuyer sur un bouton dans l’UI de votre app pour ajouter ou sélectionner un appareil. L’app remplit un descripteur spécifiant le service et les filtres à utiliser pour détecter les appareils. Elle présente ensuite l’UI d’AccessorySetupKit.
AccessorySetupKit détecte les appareils à proximité correspondant à votre filtre de service et de détection, et les présente dans l’UI. L’utilisateur sélectionne ensuite l’appareil à configurer.
Lors de la configuration, il saisit un code PIN pour confirmer le jumelage Wi-Fi Aware. Le code PIN s’affiche au niveau de l’éditeur et est saisi du côté de l’abonné.
Le système effectue ensuite le jumelage pour le compte de l’app.
Maintenant que nous avons vu le flux AccessorySetupKit, examinons le code. Pour jumeler des appareils Wi-Fi Aware avec AccessorySetupKit, créez d’abord un ASDiscoveryDescriptor où vous fournirez le nom du service et des filtres de propriétés d’appareil comme le modèle et le fournisseur. Présentez ensuite l’UI AccessorySetupKit en créant une ASAccessorySession et en y appelant showPicker. Le système s’occupe du processus de détection et de jumelage. Une fois le jumelage terminé, un nouvel ASAccessory représentant le nouvel appareil jumelé est renvoyé. Celui-ci contient un ASAccessoryWiFiAwarePairedDeviceID, qui est l’ID de l’appareil jumelé. Votre app peut utiliser cet ID pour rechercher le WAPairedDevice correspondant via le framework Wi-Fi Aware. L’appareil peut être utilisé pour initier une connexion à l’aide du framework Network.
Pour en savoir plus sur AccessorySetupKit, regardez la session « Meet AccessorySetupKit » de la WWDC24. Voyons maintenant comment votre app peut accéder à la liste des appareils jumelés.
Wi-Fi Aware représente un appareil jumelé en tant que structure WAPairedDevice. Vous pouvez obtenir la liste des appareils avec l’API allDevices sur WAPairedDevice. Vous pouvez accéder aux propriétés de l’appareil, comme le fournisseur et le nom du modèle, qui sont découvertes lors du jumelage.
L’API peut générer tous les appareils ou ceux qui correspondent à un filtre fourni.
Par exemple, pour obtenir tous les appareils correspondant à Example Inc comme nom de fournisseur, créez le filtre indiqué ici.
La liste des appareils jumelés de votre app peut changer à tout moment. Par exemple, si un appareil est supprimé des réglages, l’app peut écouter ces modifications et mettre à jour l’UI et d’autres états en conséquence. Le framework fournit un moyen simple de le faire en fournissant une séquence asynchrone via WaPairedDevice.allDevices.
Notez que les API mentionnées ici fournissent tous les appareils jumelés disponibles pour votre app, qu’ils soient accessibles ou non. Maintenant que nous avons couvert le processus de jumelage, concentrons-nous sur celui dans lequel l’application établit des connexions avec des appareils jumelés. Avant d’examiner le code, voyons d’abord le processus global permettant d’établir une connexion Wi-Fi Aware. Pour établir une connexion, deux appareils sont nécessaires. Un appareil publie le service et écoute les connexions à partir d’appareils jumelés spécifiques.
L’autre appareil s’abonne au service et recherche des appareils jumelés spécifiques auxquels se connecter. Pour économiser de l’énergie, l’écoute et la navigation doivent être limitées à la durée nécessaire à votre cas d’utilisation.
Lorsque le navigateur détecte la combinaison service-appareil que vous avez fournie, il propose des points de terminaison réseau connectables à l’app. Votre app examine ensuite les points de terminaison et établit des connexions avec un ou plusieurs d’entre eux. L’écouteur reçoit la demande de connexion et la transmet à votre app pour établir la connexion. À ce stade, les données peuvent être échangées.
Voyons comment utiliser le framework Network dans votre application pour établir une connexion Wi-Fi Aware. Avant la publication ou l’abonnement, votre app doit sélectionner les appareils jumelés d’intérêt. Dans cet exemple, l’éditeur crée un filtre pour les appareils dont le nom commence par Mon appareil.
De même, le filtre des abonnés sélectionne les appareils dont le nom du fournisseur commence par Example Inc.
Les paramètres nécessaires sont désormais disponibles pour lancer les instances d’écouteur et de navigateur à l’aide du framework Network.
Pour créer un NetworkListener, fournissez l’objet de service et le filtre d’appareil créés précédemment.
Le NetworkListener créé de cette manière n’accepte que les connexions pour le service spécifié et les appareils jumelés correspondant au filtre fourni.
Outre les paramètres Wi-Fi Aware, votre app peut configurer les paramètres réseau et le gestionnaire de mise à jour de l’état.
De même, le NetworkBrowser est créé à l’aide du service et du filtre d’appareil précédents.
Ce navigateur ne détectera que les appareils jumelés qui annoncent le service et qui correspondent au filtre.
Après avoir créé un écouteur et un navigateur, votre app peut désormais établir une connexion. Pour commencer à accepter les connexions entrantes sur l’écouteur, appelez l’opération run sur l’objet listener.
Le lancement de l’écouteur permet à d’autres appareils de découvrir votre app.
Pour commencer à vous abonner aux services sur le navigateur, appelez l’opération run sur l’objet browser.
Le lancement du navigateur détecte les appareils à proximité offrant le service. Le navigateur renvoie à l’app la liste des appareils détectés comme points de terminaison réseau.
L’app examine ensuite ces points de terminaison et détermine si le point de terminaison d’intérêt est présent.
Utilisez l’API NetworkConnection pour établir des connexions avec le point de terminaison souhaité.
Une fois la connexion établie, l’écouteur recevra un rappel pour la nouvelle connexion et la transmettra à votre app. Votre app peut désormais échanger des données à l’aide des API du framework Network. Pour économiser les ressources sans fil et l’énergie, arrêtez l’écouteur et le navigateur une fois que toutes les connexions requises ont été établies.
J’ai couvert toutes les étapes requises pour établir une connexion Wi-Fi Aware. Voyons comment optimiser les performances de connexion pour optimiser l’expérience de l’app. L’optimisation des performances nécessite d’équilibrer le débit, la latence et la consommation d’énergie. Dans la plupart des cas, le système applique des valeurs par défaut raisonnables. Mais si nécessaire, votre app peut ajuster certains paramètres de connexion.
L’un d’eux est le mode de performance Wi-Fi Aware, qui influence le cycle de service Wi-Fi Aware.
Le second est la classe de service de trafic, qui définit la priorité de transmission des paquets. Le paramètre par défaut est le meilleur effort, mais vous pouvez le définir sur vidéo interactive ou voix pour une latence plus faible.
Si vous avez des données de faible priorité, utilisez la classe de service d’arrière-plan pour éviter d’interférer avec d’autres trafics.
En général, le mode de performances en bloc est utilisé avec le meilleur effort ou la classe de service en arrière-plan. Cela réduit la consommation d’énergie, mais augmente la latence.
D’autre part, le temps réel est utilisé avec la classe de service voix ou vidéo interactive. Cela réduit la latence, mais augmente la consommation d’énergie. Avant de choisir d’utiliser le mode temps réel, demandez-vous si vous en avez vraiment besoin, car il peut avoir un impact négatif sur la décharge de la batterie. En plus de réglages ajustables pour les performances de connexion, le framework Wi-Fi Aware fournit un rapport de performances à la demande pour chaque connexion réseau. Ce rapport inclut des métriques sur l’intensité du signal, le débit et la latence. Utilisez ces informations pour ajuster les performances de votre app. Comme la puissance de la connexion Wi-Fi, les interférences environnementales et les fonctionnalités de l’appareil peuvent varier considérablement, testez les performances de votre app dans des environnements Wi-Fi très fréquentés. De plus, intégrez dans votre app les informations de connexion fournies par les protocoles réseau comme TCP.
Parlons du code et voyons comment vous pouvez utiliser les paramètres réglables. Pour rappel, les connexions Wi-Fi Aware utilisent par défaut le mode de performances en bloc avec la classe de service du meilleur effort. Si le profilage suggère que votre cas d’utilisation bénéficie d’une autre configuration, vous pouvez définir les paramètres du côté éditeur et l’instance de connexion du côté abonné pour configurer le mode de performance et la classe de service.
Ici, l’éditeur est configuré pour utiliser le mode de performance en temps réel et la classe de service Trafic vidéo interactif.
Du côté abonné, la même configuration est requise sur l’objet NetworkConnection créé par votre app.
Pour suivre la connexion Wi-Fi Aware de votre app, accédez au chemin actuel et lisez le rapport de performances. Votre app pourra ensuite agir en fonction de ce rapport et affiner l’expérience utilisateur globale.
Maintenant que vous savez comment créer une app avec Wi-Fi Aware, j’ai hâte de voir ce que vous allez en faire. Mais avant de partir, parlons de quelques prochaines étapes clés. Si vous êtes fabricant de matériel et que vous développez un appareil Wi-Fi Aware, consultez les directives sur la conception des accessoires pour garantir leur interopérabilité avec les appareils Apple. Le document de directives est disponible sur le site web Apple Developer. Suivre ces directives permettra à votre appareil de détecter et de jumeler les appareils Apple de manière fiable, d’assurer une sécurité renforcée et d’optimiser les performances de connexion. Ce guide est la ressource phare pour créer des expériences Wi-Fi Aware cohérentes et de haute qualité.
Nous vous encourageons à consulter la documentation du framework Wi-Fi Aware pour plus d’informations. Un exemple est également disponible pour montrer comment créer une app avec la technologie Wi-Fi Aware et comment différentes configurations de performances affectent notre comportement.
Enfin, si vous créez un appareil Wi-Fi Aware, le guide d’interopérabilité peut vous aider à créer une expérience optimale pour vos utilisateurs.
Merci de votre attention !

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 - Introduction
- Découvrez comment utiliser la fonction Wi-Fi Aware sur iOS et iPadOS pour créer des connexions réseau peer-to-peer à latence faible et débit élevé.
- 1:01 - Aperçu
- Wi-Fi Aware est une norme qui permet une communication directe entre appareils sans avoir besoin de routeurs ou de serveurs centraux. Elle fonctionne parallèlement aux connexions Wi-Fi classiques. Grâce à cette technologie, les appareils peuvent se repérer et établir des connexions sécurisées et flexibles pour des usages temporaires, comme le transfert de fichiers, le streaming multimédia, la gestion d’accessoires ou le partage d’écran. Wi-Fi Aware fonctionne sur différentes plateformes et assure une compatibilité totale tout en garantissant des connexions sécurisées avec authentification et chiffrement. Les apps peuvent créer leurs propres services et attribuer des rôles d’éditeur ou d’abonné (ou les deux), ce qui permet aux appareils de se reconnecter automatiquement et instantanément dès qu’ils sont à portée de l’un de l’autre.
- 7:46 - Associer
- Les appareils peuvent être jumelés à l’aide du framework DeviceDiscoveryUI ou AccessorySetupKit. DeviceDiscoveryUI est conçu pour le jumelage entre apps. Il prend aussi en charge les appareils Apple et ceux d’autres fabricants. AccessorySetupKit est spécialement conçu pour connecter des apps avec des accessoires. Une fois les appareils jumelés, les deux frameworks permettent aux apps d’accéder à la liste des appareils jumelés, de gérer cette liste, de récupérer leurs propriétés et de détecter les changements d’état du jumelage, ce qui permet à l’app d’adapter son interface et son fonctionnement en temps réel.
- 15:05 - Connecter
- Une fois jumelés, les appareils peuvent se connecter les uns aux autres. Un appareil joue le rôle d’éditeur, tandis que l’autre joue le rôle d’abonné. L’éditeur filtre les appareils spécifiques et commence l’écoute, tandis que l’abonné filtre et commence la navigation. Lorsque l’abonné a trouvé l’éditeur, il fournit des points de terminaison à l’app, qui établit ensuite les connexions. L’écouteur reçoit et transmet ces demandes de connexion, ce qui permet l’échange de données.
- 19:01 - Optimiser
- Pour optimiser les performances de connexion d’une app, le framework Wi-Fi Aware permet aux développeurs d’ajuster certains paramètres. Le framework propose deux modes de performance principaux : bulk et real-time. Le mode bulk est économe en énergie, mais présente une latence plus élevée, tandis que le mode real-time offre une latence plus faible, mais consomme plus d’énergie. Les développeurs peuvent également configurer différents niveaux de priorité pour la transmission des données, avec des options pour le meilleur effort, la vidéo interactive ou la voix et la classe de service en arrière-plan. Le framework fournit des rapports de performances à la demande qui incluent des statistiques sur la puissance du signal, le débit et la latence. Les développeurs peuvent s’en servir pour optimiser les performances de leur app en fonction de tests réels et de facteurs environnementaux.
- 22:26 - Directives
- Les fabricants de matériel qui développent des appareils Wi-Fi Aware peuvent consulter les directives de conception des accessoires Apple sur le site web des développeurs pour obtenir des informations sur l’interopérabilité, la sécurité et l’optimisation des performances. Ce guide, ainsi que la documentation sur le framework et l’exemple d’app, fournissent des ressources essentielles pour créer des expériences utilisateur de haute qualité.

Chapitres

Ressources

Vidéos connexes

WWDC24