Haptic Feedback in iOS: A Comprehensive Guide

Haptic feedback has become an integral part of modern iOS app experiences, providing tactile responses that enhance user interactions and create a more immersive interface. Apple's Taptic Engine, introduced with the iPhone 6s, enables precise and nuanced vibrations that go far beyond simple notification alerts. Whether you're building a camera app, a game, or a productivity tool, understanding the various haptic feedback APIs available in iOS is crucial for delivering polished user experiences.

iOS offers multiple approaches to implementing haptic feedback, each with its own strengths, limitations, and use cases. From high-level SwiftUI modifiers to low-level system APIs, developers have a range of tools at their disposal. However, not all haptic implementations are created equal—particularly when working with complex audio and video recording scenarios where AVAudioSession configurations can interfere with haptic delivery.

Four Ways to Implement Haptic Feedback

1. UIImpactFeedbackGenerator: The Standard Approach

The most common method for triggering haptic feedback is through UIImpactFeedbackGenerator, part of UIKit's feedback generator family:

private let impactGenerator = UIImpactFeedbackGenerator(style: .heavy)

// Prepare for optimal performance
impactGenerator.prepare()

// Trigger the haptic
impactGenerator.impactOccurred()

UIImpactFeedbackGenerator provides three built-in styles—.light, .medium, and .heavy—making it straightforward to create contextually appropriate feedback. The prepare() method primes the Taptic Engine for immediate response, reducing latency when the haptic is triggered. This API is ideal for standard UI interactions like button taps, toggles, and selection changes.

However, UIImpactFeedbackGenerator has notable limitations. It requires proper lifecycle management, can be affected by AVAudioSession configurations during audio or video recording, and may experience delays if not properly prepared. In camera applications or scenarios with complex audio routing, this method may fail to deliver haptics reliably.

2. CHHapticEngine: Advanced Custom Patterns

For developers who need fine-grained control over haptic experiences, CHHapticEngine from the Core Haptics framework offers the ability to create complex, custom haptic patterns:

private var hapticEngine: CHHapticEngine?

// Initialize and start the engine
hapticEngine = try CHHapticEngine()
try hapticEngine?.start()

// Create a custom pattern
let intensity = CHHapticEventParameter(parameterID: .hapticIntensity, value: 1.0)
let sharpness = CHHapticEventParameter(parameterID: .hapticSharpness, value: 1.0)
let event = CHHapticEvent(eventType: .hapticTransient, 
                          parameters: [intensity, sharpness], 
                          relativeTime: 0)
let pattern = try CHHapticPattern(events: [event], parameters: [])
let player = try hapticEngine?.makePlayer(with: pattern)
try player?.start(atTime: 0)

CHHapticEngine enables sophisticated haptic compositions with precise control over intensity, sharpness, timing, and duration. You can create continuous haptics, sequences, and even synchronize haptics with audio. This makes it perfect for gaming, immersive experiences, or any scenario requiring haptic choreography.

The trade-off is complexity. CHHapticEngine requires more setup code, explicit engine management, and handling of engine lifecycle events like resets and stops. Like UIImpactFeedbackGenerator, it can also be disrupted by certain AVAudioSession configurations.

3. SwiftUI's .sensoryFeedback(): Declarative Haptics

SwiftUI introduces a modern, declarative approach to haptics through the .sensoryFeedback() modifier:

@State private var sensoryFeedbackTrigger = 0

Button("Tap Me") {
    sensoryFeedbackTrigger += 1
}
.sensoryFeedback(.impact(weight: .heavy), trigger: sensoryFeedbackTrigger)

This modifier automatically handles haptic delivery when the trigger value changes, fitting naturally into SwiftUI's reactive programming model. It supports various feedback types including .impact(), .selection, .success, .warning, and .error, with customizable weights and intensities.

The .sensoryFeedback() modifier is elegant and requires minimal code, but it abstracts away control and may still encounter the same AVAudioSession issues that affect the underlying UIKit generators. It's best suited for straightforward UI feedback in SwiftUI-based applications.

4. AudioServicesPlaySystemSound(): The Low-Level Solution

When the higher-level APIs fail—particularly during camera recording or complex audio sessions—AudioServicesPlaySystemSound() provides a reliable fallback:

import AudioToolbox

AudioServicesPlaySystemSound(1519) // Strong haptic

This low-level API directly accesses the Taptic Engine hardware through system sound IDs. Common haptic system sounds include:

• 1519 - Strong haptic (peek sensation)
• 1520 - Weak haptic (pop sensation)
• 1521 - Medium haptic
• 4095 - System vibrate

Why this works when other methods don't:

1. Lower level: Directly calls the Taptic Engine hardware, bypassing UIKit and Core Haptics layers
2. No preparation needed: No lifecycle management, no need to call prepare(), no object initialization
3. Camera-compatible: This is the same API Apple's native Camera app uses for zoom haptics and shutter feedback
4. Synchronous: Fires immediately with no async delays or threading concerns
5. AVAudioSession independent: Not affected by audio session category, mode, or routing changes

The primary limitation of AudioServicesPlaySystemSound() is its lack of customization—you're restricted to predefined system haptics with no control over intensity curves or timing. However, for applications where reliability trumps customization, particularly in camera and recording contexts, this method is often the most dependable choice.

Choosing the Right Approach

The best haptic API depends on your specific needs:

• Use UIImpactFeedbackGenerator for standard UI interactions in most apps
• Use CHHapticEngine when you need custom patterns, precise timing, or audio synchronization
• Use .sensoryFeedback() for clean, declarative haptics in SwiftUI interfaces
• Use AudioServicesPlaySystemSound() when working with camera/recording features or when other methods fail due to audio session conflicts

Understanding these four approaches—and their trade-offs—ensures you can deliver reliable, high-quality haptic feedback regardless of your app's complexity or audio requirements.

code example could be found on github: https://github.com/Maxnxi/TestHaptic