Améliorez la sécurité des enfants avec PermissionKit

Améliorez la sécurité des enfants avec PermissionKit

Découvrez comment PermissionKit vous aide à améliorer la sécurité des communications pour les enfants dans votre app. Nous vous montrerons comment utiliser ce nouveau framework pour créer des expériences de communication adaptées à l'âge des utilisateurs et exploiter Family Sharing pour obtenir les approbations parentales. Vous apprendrez à créer des demandes d'autorisation qui s'intègrent parfaitement à Messages, à gérer les réponses des parents et à adapter votre interface utilisateur pour les enfants. Pour tirer le meilleur parti de cette séance, nous vous recommandons de regarder d'abord « Offrir des expériences adaptées à l'âge dans votre application » de la WWDC25.

Chapitres
- 0:00 - Introduction
- 2:40 - Découvrez PermissionKit
- 3:26 - Adaptez votre interface utilisateur aux enfants
- 4:38 - Créez une expérience de type « demander »
- 7:02 - Réponses des parents/tuteurs
- 10:27 - D’autres façons d’assurer la sécurité des enfants
Ressources
Vidéos connexes

WWDC25
- Proposer des expériences adaptées à l’âge dans votre app
Bonjour, je suis Andrew, ingénieur dans l’équipe Famille. Bienvenue dans « Enhance child safety with PermissionKit ». La priorité absolue d’un parent est d’assurer la sécurité de ses enfants. Dans un environnement numérique, la protection des enfants commence par un dialogue entre eux et leurs parents ou tuteurs.
C’est d’autant plus important quand il s’agit de savoir avec qui l’enfant échange en ligne. Démarrer cette conversation depuis une app peut être complexe et nécessiter des ressources techniques conséquentes. Le meilleur endroit pour un parent pour parler à son enfant, c’est là où ils échangent déjà : dans l’app Messages. Sous iOS, iPadOS et macOS 26, vous pouvez démarrer une conversation entre un enfant et ses parents dans Messages à l’aide de PermissionKit.
Avec PermissionKit, les enfants peuvent demander à parler à leurs parents leur accord pour parler à quelqu’un. Dans cette vidéo, je vais d’abord vous présenter le nouveau framework PermissionKit.
Ensuite, je vous montrerai comment adapter l’UI de votre app pour mieux protéger les enfants avec cette nouvelle API.
Je vous montrerai ensuite comment permettre à un enfant d’envoyer une demande d’autorisation à ses parents ou tuteurs directement depuis Messages.
Et pour finir, je vous montrerai comment recevoir et traiter les réponses des parents. Cette vidéo suppose que votre app permet de communiquer et que vous pouvez déjà connaître l’âge ou la tranche d’âge de vos utilisateurs. L’API PermissionKit que je vais vous présenter ne doit être utilisée que si vous savez que l’utilisateur actuel est un enfant. Si vous n’avez pas encore de système pour savoir si l’utilisateur est un enfant, utilisez la nouvelle API Declared Age Range.
Les parents peuvent autoriser leurs enfants à partager leur tranche d’âge sur leur compte, qui est récupérée par l’API Declared Age Range. Regardez « Deliver age appropriate experiences in your app » de la WWDC25 pour plus de détails.
Voici quelques éléments à prendre en compte pour déterminer si PermissionKit convient à votre app.
PermissionKit s’appuie sur le groupe de partage familial de l’utilisateur pour connecter les enfants à leurs parents ou tuteurs.
Cela signifie que les utilisateurs doivent faire partie d’un groupe de partage familial pour profiter de PermissionKit. Si l’enfant ne fait pas partie d’un groupe de partage familial lors de la demande, l’API renverra une réponse par défaut. De plus, les parents ou tuteurs doivent activer les limites de communication pour l’enfant. L’API renverra également une réponse par défaut si les limites de communication ne sont pas activées.
Je vais à présent vous présenter PermissionKit. PermissionKit est un nouveau framework qui simplifie la création d’expériences de demande d’autorisation cohérentes et fluides entre le demandeur et l’autorité concernée. Sous iOS, iPadOS et macOS 26, vous pouvez contribuer à la sécurité des enfants en ligne en adoptant PermissionKit. PermissionKit permet de lancer une conversation dans Messages entre un enfant et les parents ou tuteurs de son groupe de partage familial. Dans votre app, un enfant peut demander à échanger avec une nouvelle personne via Messages. Les parents peuvent approuver ou refuser la demande de leur enfant directement dans la conversation Messages générée.
Je vais vous montrer comment adopter PermissionKit, en commençant par rendre votre UI adaptée à l’âge des enfants. Landmarks est une app dédiée à la découverte des monuments. Nous allons apprendre à ajouter une fonctionnalité de chat à l’app, pour que les utilisateurs puissent échanger sur leurs coups de cœur. Landmarks est conçue pour tous les âges et convient parfaitement à PermissionKit.
Pour les enfants, votre app doit masquer le contenu provenant d’expéditeurs inconnus. Cela peut inclure un aperçu de message, des photos de profil ou tout autre contenu sensible inapproprié pour les enfants.
On peut utiliser la méthode knownHandles(in:) du singleton CommunicationLimits, en l’appelant de manière asynchrone avec await. À partir d’un ensemble de contacts, cette API effectue une recherche optimisée et renvoie le sous-ensemble reconnu par le système. Cela peut être complété par les infos de vos propres bases de données. Inutile de repartir de zéro si ces données sont déjà disponibles dans vos propres systèmes. Ensuite, vérifiez si le contact ou le groupe de contacts avec lequel l’enfant veut interagir ne contient que des contacts connus. N’affichez le contenu sous-jacent que si les contacts sont reconnus.
Ensuite, je vous montrerai comment permettre à l’enfant d’envoyer une demande d’autorisation à ses parents. PermissionKit fournit une abstraction qui regroupe tous les détails d’une demande d’autorisation d’un enfant. Chaque demande comporte un sujet qui précise le contenu de la question. Par exemple, un sujet de communication contient toutes les informations sur la personne ou le groupe de personnes, que l’enfant tente de contacter. Cela inclut au minimum un identifiant, comme un numéro de téléphone, une adresse e-mail ou un nom d’utilisateur.
Passons maintenant au code. Créez une demande d’autorisation en y transmettant les contacts inconnus.
Vous pouvez également ajouter des métadonnées pour certains contacts. Privilégiez l’ajout du maximum de métadonnées possible. Toutes les métadonnées fournies seront affichées aux parents et tuteurs par le système, et pourront les aider à décider d’approuver ou de refuser la demande de leur enfant. Pour cela, créez un CommunicationTopic.
CommunicationTopic utilise PersonInformation.
PersonInformation permet de gérer l’identifiant, le nom et une image. Vous pouvez également définir des actions sur le sujet.
Les actions choisies doivent correspondre à la façon dont l’enfant tente de communiquer avec les personnes spécifiées.
Selon les actions sélectionnées, le système utilisera un libellé spécifique pour présenter la demande au parent lors de la validation.
Ici, j’utilise « message », mais vous pouvez aussi indiquer « appel », « vidéo », etc.
Enfin, initialisez votre PermissionQuestion avec votre CommunicationTopic personnalisé.
Maintenant, avec la PermissionQuestion créée, intégrez un CommunicationLimitsButton dans votre vue SwiftUI.
Lorsque l’enfant touche votre bouton, une invite système s’affiche lui permettant d’envoyer la demande à ses parents et tuteurs via l’app Messages.
Pour les apps UIKit, utilisez le singleton CommunicationLimits pour lancer la demande sur l’appareil de l’enfant. Vous devrez fournir un UIViewController, que le système utilisera pour afficher l’UI.
Vous pouvez aussi utiliser le singleton CommunicationLimits pour lancer la demande sur l’appareil de l’enfant dans les apps AppKit. Il vous suffit de fournir un NSWindow.
Et voilà pour la demande d’autorisation. Il ne reste plus qu’à gérer les réponses fournies par les parents et tuteurs. Lorsque le parent répond dans Messages, votre app sera lancée en arrière-plan sur l’appareil de l’enfant. Vous devrez alors gérer ces réponses dès leur réception.
Peu après le lancement de votre app, récupérez un AsyncSequence via CommunicationLimits et parcourez-le en tâche d’arrière-plan pour suivre les mises à jour des autorisations. Lorsqu’une réponse est reçue, profitez-en pour mettre à jour votre UI ou enregistrer de nouvelles données dans vos bases.
Et voilà ! C’est tout. Je vais tout rassembler et voir comment cela fonctionne dans Landmarks. L’appareil à gauche est celui de l’enfant, et celui à droite appartient à un parent. Dans Landmarks sur l’appareil de l’enfant, nous sommes dans la nouvelle vue de discussions que j’ai ajoutée.
Par défaut, les aperçus des messages provenant de tous les contacts inconnus sont masqués pour l’enfant.
En ouvrant une conversation, on constate que le contenu du message est caché à l’enfant, qui ne peut pas répondre sans demander d’abord l’autorisation à ses parents ou tuteurs.
Quand l’enfant touche le bouton des limites de communication, une alerte s’affiche. Elle lui permet de confirmer son souhait d’envoyer un message à ses parents ou tuteurs. Il peut aussi obtenir l’autorisation de ses parents ou tuteurs en personne en utilisant le code de « Temps d’écran ». Si l’enfant sélectionne « Demander » dans l’alerte, une fenêtre de rédaction Messages s’ouvre, avec les parents et tuteurs du groupe familial ajoutés dans le champ « À » et la demande déjà saisie dans la zone de texte.
L’enfant peut ajouter un nom pour cette personne en appuyant sur le bouton « Ajouter ou modifier le nom ». Si vous fournissez des métadonnées pour la personne via l’API PermissionQuestion évoquée précédemment, elles apparaîtront ici. Elles seront affichées aux parents et aux tuteurs lorsqu’ils examineront la demande sur leurs appareils.
Dès que l’enfant touche « Envoyer », la demande est transmise à ses parents et tuteurs comme un iMessage classique.
Sur l’appareil du parent, la demande de l’enfant s’affiche dans Messages.
Les parents peuvent soit refuser directement à partir de la bulle, soit choisir de vérifier cette demande.
S’ils l’examinent, ils verront plus de détails et pourront choisir d’approuver ou de refuser.
Quelle que soit la décision du parent, l’enfant recevra automatiquement une notification l’informant du choix effectué. Au moment où la notification est envoyée à l’enfant, la décision du parent est également transmise directement à votre app en arrière-plan. Réagissez à cette décision en mettant à jour, par exemple, votre UI et vos caches locaux, ou en envoyant les infos à vos serveurs.
Maintenant que le parent a approuvé, l’enfant peut voir et répondre aux messages de cette personne dans Landmarks. Vous connaissez désormais PermissionKit, alors voici d’autres éléments à prendre en compte pour renforcer la sécurité des enfants dans votre app. Utilisez PermissionKit comme tremplin pour étendre ces expériences en dehors des plates-formes Apple, comme le site web de votre app, en conservant les infos obtenues sur vos propres serveurs. Et ne vous arrêtez pas à PermissionKit. Évaluez si votre app convient à nos autres API dédiées à la sécurité des familles et des enfants. Voici, par exemple, d’autres moyens de protéger les enfants grâce à nos API. La nouvelle API Sensitive Content Analysis protège les enfants en détectant et en bloquant la nudité lors des appels vidéo en direct. La nouvelle API Declared Age Range permet de créer des expériences sûres et adaptées à l’âge des enfants.
Le framework Temps d’écran fournit les outils nécessaires pour aider les parents et tuteurs à superviser la navigation web de leurs enfants. Le framework Contrôles familiaux aide les apps à offrir leurs propres fonctionnalités de contrôle parental.
Maintenant que vous savez comment renforcer la sécurité des enfants dans votre app grâce à PermissionKit, voici les prochaines étapes. Déterminez la tranche d’âge de chacun de vos utilisateurs, en utilisant les données de vos serveurs ou la nouvelle API Declared Age Range. Puis, adaptez l’UI de votre app pour les enfants. Enfin, adoptez PermissionKit. Créez les questions à poser et gérez les réponses des parents ou tuteurs.
Merci de m’avoir permis de vous présenter PermissionKit.

import PermissionKit

let knownHandles = await CommunicationLimits.current.knownHandles(in: conversation.participants)

if knownHandles.isSuperset(of: conversation.participants) {
    // Show content
} else {
    // Hide content
}

5:15 - Create a question

import PermissionKit

var question = PermissionQuestion(handles: [
    CommunicationHandle(value: "dragonslayer42", kind: .custom),
    CommunicationHandle(value: "progamer67", kind: .custom)
])

5:38 - Create a question - additional metadata

import PermissionKit

let people = [
    PersonInformation(
        handle: CommunicationHandle(value: "dragonslayer42", kind: .custom),
        nameComponents: nameComponents,
        avatarImage: profilePic
    ),
    PersonInformation(
        handle: CommunicationHandle(value: "progamer67", kind: .custom)
    )
]

var topic = CommunicationTopic(personInformation: people)
topic.actions = [.message]

var question = PermissionQuestion(communicationTopic: topic)

6:25 - Ask a question - SwiftUI

import PermissionKit
import SwiftUI

struct ContentView: View {
    let question: PermissionQuestion<CommunicationTopic>

    var body: some View {
        // ...
        CommunicationLimitsButton(question: question) {
            Label("Ask Permission", systemImage: "paperplane")
        }
    }
}

6:43 - Ask a question - UIKit

import PermissionKit
import UIKit

try await CommunicationLimits.current.ask(question, in: viewController)

6:54 - Ask a question - AppKit

import PermissionKit
import AppKit

try await CommunicationLimits.current.ask(question, in: window)

7:19 - Parent/guardian responses

import PermissionKit
import SwiftUI

struct ChatsView: View {
    @State var isShowingResponseAlert = false

    var body: some View {
        List {
           // ...
        }
        .task {
            let updates = CommunicationLimits.current.updates
            for await update in updates {
                // Received a response!
                self.isShowingResponseAlert = true
            }
        }
    }
}

- 0:00 - Introduction
- PermissionKit est un nouveau framework pour iOS, iPadOS et macOS 26 qui permet de gérer plus facilement les demandes d’autorisation. Il facilite notamment les échanges via Messages entre les enfants et leurs parents ou tuteurs lorsqu’une nouvelle autorisation de communication est nécessaire.
- 2:40 - Découvrez PermissionKit
- Grâce à PermissionKit, les enfants peuvent facilement solliciter l’accord de leurs parents ou tuteurs directement via Messages avant d’échanger avec de nouveaux contacts en ligne. Ce système s’appuie sur les groupes de Partage familial et requiert l’activation des restrictions de communication. L’objectif est d’accompagner les développeurs dans la création d’environnements de communication plus sécurisés pour les enfants, tout en favorisant un dialogue ouvert et transparent entre parents et enfants concernant leurs interactions sur Internet.
- 3:26 - Adaptez votre interface utilisateur aux enfants
- PermissionKit contribue à adapter les apps à l’âge des utilisateurs. Dans l’exemple d’app Landmarks, une nouvelle fonctionnalité de chat masque aux enfants le contenu provenant d’expéditeurs inconnus. Utilisez la méthode « knownHandles(in:) » de restriction des communications pour vérifier si le système ou votre base de données reconnaît les identifiants, et n’affichez le contenu aux enfants qu’à partir d’identifiants connus.
- 4:38 - Créez une expérience de type « demander »
- Créez des questions d’autorisation que les enfants pourront envoyer à leurs parents. Ces questions portent sur des sujets tels que la communication et précisent la personne que l’enfant souhaite contacter (pseudo, nom, image) et le moyen de communication (message, appel, vidéo). Initialisez une « PermissionQuestion » avec un « CommunicationTopic », puis créez un « CommunicationLimitsButton » pour déclencher une invite système, qui permet à l’enfant d’envoyer la demande à ses parents pour approbation via Messages. Les apps UIKit et AppKit peuvent lancer le flux de demande sur l’appareil de l’enfant avec le singleton Communication Limits.
- 7:02 - Réponses des parents/tuteurs
- Dès réception d’une réponse parentale dans Messages, l’app se lance en arrière-plan sur l’appareil de l’enfant. L’app obtient ensuite une « AsyncSequence » à partir du singleton Communication Limits afin de surveiller les mises à jour des autorisations. Lorsque le système reçoit une réponse, l’app met à jour son interface utilisateur ou ses bases de données en conséquence. Dans l’app Landmarks, les messages et le contenu provenant de contacts inconnus sont automatiquement masqués pour les enfants, en attendant l’approbation des parents. Les enfants peuvent demander l’autorisation de communiquer avec de nouveaux contacts, et les parents peuvent examiner et approuver ou refuser ces demandes depuis leur app Messages. L’app de l’enfant est ensuite informée de la décision du parent, ce qui permet à l’enfant de voir les messages et d’y répondre s’ils ont été approuvés.
- 10:27 - D’autres façons d’assurer la sécurité des enfants
- De nouvelles API et de nouveaux frameworks permettent d’améliorer la sécurité des enfants dans les apps en détectant la nudité dans les flux en direct, en vérifiant l’âge des utilisateurs et en activant le contrôle parental. Déterminez l’âge des utilisateurs, adaptez les interfaces utilisateur des apps et utilisez PermissionKit afin de créer des expériences sûres et adaptées à l’âge des enfants.

Chapitres

Ressources

Vidéos connexes

WWDC25