Que fait Gestes SwiftUI ?
Guide complet de la reconnaissance des gestes SwiftUI avec des motifs de composition, de gestion d'état et d'intégration de l'accessibilité.
Quand utiliser cette compétence
- Implémenter des gestes de tap, glisser, appui long, zoom ou rotation
- Composer plusieurs gestes (simultanément, séquentiellement, exclusivement)
- Gérer l'état des gestes avec GestureState
- Créer des reconnaisseurs de gestes personnalisés
- Déboguer des conflits de gestes ou des gestes non réactifs
- Rendre les gestes accessibles avec VoiceOver
- Gestion des gestes multiplateforme (iOS, macOS, visionOS)
Exemples de prompts
Voici des questions réelles que les développeurs posent et auxquelles cette compétence est conçue pour répondre :
1. "Mon geste de glissement ne fonctionne pas – la vue ne bouge pas quand je glisse. Comment puis-je le déboguer ?"
→ La compétence couvre les motifs de gestion d'état de DragGesture et montre comment mettre à jour correctement le décalage de la vue avec @GestureState.
2. "J'ai à la fois un geste de tap et un geste de glissement sur la même vue. Le tap fonctionne mais pas le glissement. Comment puis-je résoudre cela ?"
→ La compétence démontre la composition des gestes avec .simultaneously, .sequenced et .exclusively pour résoudre les conflits de gestes.
3. "Je veux que les utilisateurs fassent un appui long avant de pouvoir glisser un élément. Comment chaîner les gestes ?"
→ La compétence montre le motif .sequenced pour combiner LongPressGesture avec DragGesture dans le bon ordre.
4. "Mon état de geste ne se réinitialise pas quand le geste se termine. La vue reste dans la mauvaise position."
→ La compétence couvre le comportement de réinitialisation automatique de @GestureState et le paramètre updating pour une gestion d'état correcte.
5. "Les utilisateurs de VoiceOver ne peuvent pas accéder aux fonctionnalités qui nécessitent des gestes. Comment rendre les gestes accessibles ?"
→ La compétence démontre les motifs .accessibilityAction et fournit des interactions alternatives pour les utilisateurs de VoiceOver.
Choisir le bon geste (Arbre de décision)
De quelle interaction avez-vous besoin ?
├─ Appui/clic simple ?
│ └─ Utilisez Button (recommandé) ou TapGesture
│
├─ Mouvement de glissement/pan ?
│ └─ Utilisez DragGesture
│
├─ Maintien avant action ?
│ └─ Utilisez LongPressGesture
│
├─ Pincer pour zoomer ?
│ └─ Utilisez MagnificationGesture
│
├─ Rotation à deux doigts ?
│ └─ Utilisez RotationGesture
│
├─ Plusieurs gestes ensemble ?
│ ├─ Les deux en même temps ? → .simultaneously
│ ├─ L'un après l'autre ? → .sequenced
│ └─ L'un OU l'autre ? → .exclusively
│
└─ Comportement personnalisé complexe ?
└─ Créez un geste personnalisé conforme au protocole Gesture
Motif 1 : Reconnaissance de base des gestes
TapGesture
❌ INCORRECT (Tap personnalisé sur une vue non sémantique)
Text("Soumettre")
.onTapGesture {
soumettreFormulaire()
}
Problèmes :
- N'est pas annoncé comme un bouton à VoiceOver
- Pas de retour visuel de pression
- Ne respecte pas les paramètres d'accessibilité
✅ CORRECT (Utilisez Button pour les actions de tap)
Button("Soumettre") {
soumettreFormulaire()
}
.buttonStyle(.bordered)
Quand utiliser TapGesture : Uniquement lorsque vous avez besoin des données du tap (emplacement, nombre) ou d'un comportement de tap non standard :
Image("carte")
.onTapGesture(count: 2) { // Double tap pour les détails
afficherDetails()
}
.onTapGesture { location in // Simple tap pour épingler
ajouterEpingle(at: location)
}
DragGesture
❌ INCORRECT (Mutation directe de l'état dans le geste)
@State private var offset = CGSize.zero
var body: some View {
Cercle()
.offset(offset)
.gesture(
DragGesture()
.onChanged { value in
offset = value.translation // ❌ Met à jour chaque frame, provoque des à-coups
}
)
}
Problèmes :
- La vue se met à jour à chaque événement de glissement (60 à 120 fois par seconde)
- Aucun moyen de réinitialiser à la position d'origine
- Perd l'état intermédiaire si le glissement est annulé
✅ CORRECT (Utilisez GestureState pour l'état temporaire)
@GestureState private var dragOffset = CGSize.zero
@State private var position = CGSize.zero
var body: some View {
Cercle()
.offset(x: position.width + dragOffset.width,
y: position.height + dragOffset.height)
.gesture(
DragGesture()
.updating($dragOffset) { value, state, _ in
state = value.translation // Temporaire pendant le glissement
}
.onEnded { value in
position.width += value.translation.width // Valider la finale
position.height += value.translation.height
}
)
}
Pourquoi : GestureState se réinitialise automatiquement à sa valeur initiale lorsque le geste se termine, évitant ainsi la corruption d'état.
LongPressGesture
@GestureState private var isDetectingLongPress = false
@State private var completedLongPress = false
var body: some View {
Text("Appuyez et maintenez")
.foregroundStyle(isDetectingLongPress ? .red : .blue)
.gesture(
LongPressGesture(minimumDuration: 1.0)
.updating($isDetectingLongPress) { currentState, gestureState, _ in
gestureState = currentState // Retour visuel pendant l'appui
}
.onEnded { _ in
completedLongPress = true // Action après le maintien
}
)
}
Paramètres clés :
minimumDuration: Durée du maintien (par défaut 0,5 seconde)maximumDistance: Distance maximale de mouvement du doigt avant annulation (par défaut 10 points)
MagnificationGesture
@GestureState private var magnificationAmount = 1.0
@State private var currentZoom = 1.0
var body: some View {
Image("photo")
.scaleEffect(currentZoom * magnificationAmount)
.gesture(
MagnificationGesture()
.updating($magnificationAmount) { value, state, _ in
state = value.magnification
}
.onEnded { value in
currentZoom *= value.magnification
}
)
}
Notes de plateforme :
- iOS : Geste de pincement avec deux doigts
- macOS : Pincement sur le trackpad
- visionOS : Geste de pincement dans l'espace 3D
RotationGesture
@GestureState private var rotationAngle = Angle.zero
@State private var currentRotation = Angle.zero
var body: some View {
Rectangle()
.fill(.blue)
.frame(width: 200, height: 200)
.rotationEffect(currentRotation + rotationAngle)
.gesture(
RotationGesture()
.updating($rotationAngle) { value, state, _ in
state = value.rotation
}
.onEnded { value in
currentRotation += value.rotation
}
)
}
Motif 2 : Composition de gestes
Gestes simultanés
Utilisez quand : Deux gestes doivent fonctionner en même temps
@GestureState private var dragOffset = CGSize.zero
@GestureState private var magnificationAmount = 1.0
var body: some View {
Image("photo")
.offset(dragOffset)
.scaleEffect(magnificationAmount)
.gesture(
DragGesture()
.updating($dragOffset) { value, state, _ in
state = value.translation
}
.simultaneously(with:
MagnificationGesture()
.updating($magnificationAmount) { value, state, _ in
state = value.magnification
}
)
)
}
Cas d'utilisation : Visionneuse de photos où vous pouvez glisser ET pincer-zoomer en même temps.
Gestes séquencés
Utilisez quand : Un geste doit se terminer avant que le suivant ne commence
@State private var isLongPressing = false
@GestureState private var dragOffset = CGSize.zero
var body: some View {
Cercle()
.offset(dragOffset)
.gesture(
LongPressGesture(minimumDuration: 0.5)
.onEnded { _ in
isLongPressing = true
}
.sequenced(before:
DragGesture()
.updating($dragOffset) { value, state, _ in
state = value.translation
}
.onEnded { _ in
isLongPressing = false
}
)
)
}
Cas d'utilisation : Écran d'accueil iOS — appuyez longuement pour entrer en mode édition, puis glissez pour réorganiser.
Gestes exclusifs
Utilisez quand : Un seul geste doit gagner, pas les deux
var body: some View {
Rectangle()
.gesture(
TapGesture(count: 2) // Double tap
.onEnded { _ in
zoomer()
}
.exclusively(before:
TapGesture(count: 1) // Simple tap
.onEnded { _ in
selectionner()
}
)
)
}
Pourquoi : Sans .exclusively, un double tap déclenche à la fois les gestionnaires de simple et double tap.
Comment cela fonctionne : SwiftUI attend de voir si un second tap arrive. Si oui → le double tap gagne. Si non → le simple tap gagne.
Motif 3 : GestureState vs State
Quand utiliser quoi
| Cas d'utilisation | Type d'état | Pourquoi |
|---|---|---|
| Retour temporaire pendant le geste | @GestureState | Se réinitialise automatiquement quand le geste se termine |
| Valeur finale validée | @State | Persiste après le geste |
| Animation pendant le geste | @GestureState | Transitions fluides |
| Persistance des données | @State | Survit aux mises à jour de la vue |
Exemple complet : Carte déplaçable
struct CarteDeplacable: View {
@GestureState private var dragOffset = CGSize.zero // Temporaire
@State private var position = CGSize.zero // Permanent
var body: some View {
RoundedRectangle(cornerRadius: 12)
.fill(.blue)
.frame(width: 300, height: 200)
.offset(
x: position.width + dragOffset.width,
y: position.height + dragOffset.height
)
.gesture(
DragGesture()
.updating($dragOffset) { value, state, transaction in
state = value.translation
// Activer l'animation pour un retour fluide
transaction.animation = .interactiveSpring()
}
.onEnded { value in
// Valider la position finale avec animation
withAnimation(.spring()) {
position.width += value.translation.width
position.height += value.translation.height
}
}
)
}
}
Aperçu clé : Le troisième paramètre transaction de GestureState vous permet de personnaliser l'animation pendant le geste.
Motif 4 : Gestes personnalisés
Quand créer des gestes personnalisés
- Besoin d'un comportement de geste non fourni par les gestes intégrés
- Souhait d'encapsuler une logique de geste complexe
- Réutilisation d'un geste dans plusieurs vues
Exemple : Geste de balayage avec direction
struct GesteBalayage: Gesture {
enum Direction {
case gauche, droite, haut, bas
}
let distanceMinimale: CGFloat
let espaceCoordonnees: CoordinateSpace
init(distanceMinimale: CGFloat = 50, espaceCoordonnees: CoordinateSpace = .local) {
self.distanceMinimale = distanceMinimale
self.espaceCoordonnees = espaceCoordonnees
}
// La valeur est la direction
typealias Value = Direction
// Le corps s'appuie sur DragGesture
var body: AnyGesture<Direction> {
DragGesture(minimumDistance: distanceMinimale, coordinateSpace: espaceCoordonnees)
.map { value in
let horizontal = value.translation.width
let vertical = value.translation.height
if abs(horizontal) > abs(vertical) {
return horizontal < 0 ? .gauche : .droite
} else {
return vertical < 0 ? .haut : .bas
}
}
.eraseToAnyGesture()
}
}
// Utilisation
Text("Balayez-moi")
.gesture(
GesteBalayage()
.onEnded { direction in
switch direction {
case .gauche: supprimerElement()
case .droite: archiverElement()
default: break
}
}
)
Motif 5 : Vélocité et prédiction des gestes
Accéder à la vélocité
@State private var velocity: CGSize = .zero
var body: some View {
Cercle()
.gesture(
DragGesture()
.onEnded { value in
// value.velocity est obsolète dans iOS 18+
// Utilisez value.predictedEndLocation et time
let deltaTemps = value.time.timeIntervalSince(value.startLocation.time)
let distance = value.translation
velocity = CGSize(
width: distance.width / deltaTemps,
height: distance.height / deltaTemps
)
// Animer avec momentum
withAnimation(.interpolatingSpring(stiffness: 100, damping: 15)) {
appliquerMomentum(velocity: velocity)
}
}
)
}
Emplacement de fin prédit (iOS 16+)
DragGesture()
.onChanged { value in
// Où le geste finira probablement en fonction de la vélocité
let predit = value.predictedEndLocation
// Afficher un aperçu de l'endroit où l'élément atterrira
afficherApercu(at: predit)
}
Cas d'utilisation : Physique élastique, défilement par momentum, animations de lancer.
Motif 6 : Intégration de l'accessibilité
Rendre les gestes personnalisés accessibles
❌ INCORRECT (Gestes uniquement, pas de support VoiceOver)
Image("curseur")
.gesture(
DragGesture()
.onChanged { value in
mettreAJourVolume(value.translation.width)
}
)
Problème : Les utilisateurs de VoiceOver ne peuvent pas ajuster le curseur.
✅ CORRECT (Ajouter des actions d'accessibilité)
@State private var volume: Double = 50
var body: some View {
Image("curseur")
.gesture(
DragGesture()
.onChanged { value in
volume = calculerVolume(from: value.translation.width)
}
)
.accessibilityElement()
.accessibilityLabel("Volume")
.accessibilityValue("\(Int(volume))%")
.accessibilityAdjustableAction { direction in
switch direction {
case .increment:
volume = min(100, volume + 5)
case .decrement:
volume = max(0, volume - 5)
@unknown default:
break
}
}
}
Pourquoi : Les utilisateurs de VoiceOver peuvent maintenant balayer vers le haut/bas pour ajuster le volume sans voir ni utiliser le geste.
Alternatives clavier (macOS)
Rectangle()
.gesture(
DragGesture()
.onChanged { value in
deplacer(by: value.translation)
}
)
.onKeyPress(.upArrow) {
deplacer(by: CGSize(width: 0, height: -10))
return .handled
}
.onKeyPress(.downArrow) {
deplacer(by: CGSize(width: 0, height: 10))
return .handled
}
.onKeyPress(.leftArrow) {
deplacer(by: CGSize(width: -10, height: 0))
return .handled
}
.onKeyPress(.rightArrow) {
deplacer(by: CGSize(width: 10, height: 0))
return .handled
}
Motif 7 : Gestes multiplateforme
iOS vs macOS vs visionOS
| Geste | iOS | macOS | vision
...
[Le reste du tableau est tronqué pour la traduction]