SwiftUI sensoryFeedback와 CoreHaptics 완벽 가이드: 커스텀 햅틱 패턴과 UX 피드백 (iOS 17~26)

import SwiftUI

struct LikeButton: View {
    @State private var likeCount = 0

    var body: some View {
        Button {
            likeCount += 1
        } label: {
            Label("좋아요 \(likeCount)", systemImage: "heart.fill")
        }
        .sensoryFeedback(.impact(weight: .light, intensity: 0.7), trigger: likeCount)
    }
}

@State private var scrollOffset: CGFloat = 0
private let snapThreshold: CGFloat = 80

var body: some View {
    ScrollView(.horizontal) {
        // ... 콘텐츠
    }
    .sensoryFeedback(.selection, trigger: scrollOffset) { oldValue, newValue in
        // 임계값을 넘을 때만 발생 (계속 발생 방지)
        let oldBucket = Int(oldValue / snapThreshold)
        let newBucket = Int(newValue / snapThreshold)
        return oldBucket != newBucket
    }
}

import CoreHaptics
import Observation

@Observable
final class HapticsManager {
    private var engine: CHHapticEngine?
    private(set) var supportsHaptics: Bool = false

    init() {
        supportsHaptics = CHHapticEngine.capabilitiesForHardware().supportsHaptics
        guard supportsHaptics else { return }
        prepareEngine()
    }

    private func prepareEngine() {
        do {
            let engine = try CHHapticEngine()
            engine.stoppedHandler = { reason in
                // .audioSessionInterrupt, .applicationSuspended 등
                print("Haptic engine stopped: \(reason)")
            }
            engine.resetHandler = { [weak self] in
                // 서버 프로세스가 재시작된 경우, 엔진을 다시 start해야 함
                try? self?.engine?.start()
            }
            try engine.start()
            self.engine = engine
        } catch {
            print("Haptic engine init failed: \(error)")
        }
    }

    func play(_ pattern: CHHapticPattern) {
        guard supportsHaptics, let engine else { return }
        do {
            try engine.start() // 정지 상태면 다시 시작
            let player = try engine.makePlayer(with: pattern)
            try player.start(atTime: CHHapticTimeImmediate)
        } catch {
            print("Play failed: \(error)")
        }
    }
}

import CoreHaptics

func heartbeatPattern() throws -> CHHapticPattern {
    let first = CHHapticEvent(
        eventType: .hapticTransient,
        parameters: [
            CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.9),
            CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.3)
        ],
        relativeTime: 0
    )
    let second = CHHapticEvent(
        eventType: .hapticTransient,
        parameters: [
            CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.6),
            CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.3)
        ],
        relativeTime: 0.18 // 180ms 간격 = 심박수 약 66bpm
    )
    return try CHHapticPattern(events: [first, second], parameters: [])
}

let continuous = CHHapticEvent(
    eventType: .hapticContinuous,
    parameters: [
        CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.5),
        CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.5)
    ],
    relativeTime: 0,
    duration: 1.5
)

// 인텐시티를 0 → 1 → 0으로 부드럽게 변화
let intensityCurve = CHHapticParameterCurve(
    parameterID: .hapticIntensityControl,
    controlPoints: [
        .init(relativeTime: 0.0, value: 0.0),
        .init(relativeTime: 0.75, value: 1.0),
        .init(relativeTime: 1.5, value: 0.0)
    ],
    relativeTime: 0
)

let pattern = try CHHapticPattern(events: [continuous], parameterCurves: [intensityCurve])

func loadPattern(named name: String) throws -> CHHapticPattern {
    guard let url = Bundle.main.url(forResource: name, withExtension: "ahap") else {
        throw NSError(domain: "Haptics", code: 404)
    }
    let data = try Data(contentsOf: url)
    let dict = try JSONSerialization.jsonObject(with: data) as? [CHHapticPattern.Key.RawValue: Any] ?? [:]
    return try CHHapticPattern(dictionary: dict)
}

{
  "Version": 1.0,
  "Pattern": [
    {
      "Event": {
        "Time": 0.0,
        "EventType": "HapticContinuous",
        "EventDuration": 2.0,
        "EventParameters": [
          { "ParameterID": "HapticIntensity", "ParameterValue": 0.2 },
          { "ParameterID": "HapticSharpness", "ParameterValue": 0.5 }
        ]
      }
    },
    {
      "ParameterCurve": {
        "ParameterID": "HapticIntensityControl",
        "Time": 0.0,
        "ParameterCurveControlPoints": [
          { "Time": 0.0, "ParameterValue": 0.0 },
          { "Time": 2.0, "ParameterValue": 1.0 }
        ]
      }
    }
  ]
}

let audioURL = Bundle.main.url(forResource: "coin", withExtension: "wav")!
let audioResource = try engine.registerAudioResource(audioURL, options: [:])

let audioEvent = CHHapticEvent(
    audioResourceID: audioResource,
    parameters: [
        CHHapticEventParameter(parameterID: .audioVolume, value: 0.8)
    ],
    relativeTime: 0
)

let hapticEvent = CHHapticEvent(
    eventType: .hapticTransient,
    parameters: [
        CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.9),
        CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.7)
    ],
    relativeTime: 0
)

let pattern = try CHHapticPattern(events: [audioEvent, hapticEvent], parameters: [])

@State private var swipeProgress: CGFloat = 0
@State private var didConfirm = false

var body: some View {
    Rectangle()
        .frame(height: 60)
        .offset(x: -swipeProgress)
        .gesture(
            DragGesture()
                .onChanged { value in
                    swipeProgress = min(abs(value.translation.width), 120)
                    if swipeProgress >= 120 && !didConfirm {
                        didConfirm = true
                    }
                }
                .onEnded { _ in
                    withAnimation(.spring(response: 0.4, dampingFraction: 0.75)) {
                        swipeProgress = 0
                    }
                    didConfirm = false
                }
        )
        .sensoryFeedback(.impact(weight: .medium, intensity: 0.8), trigger: didConfirm) { _, new in new }
}

@State private var pressProgress: CGFloat = 0
@State private var timerBucket: Int = 0

var body: some View {
    Circle()
        .trim(from: 0, to: pressProgress)
        .stroke(lineWidth: 6)
        .rotationEffect(.degrees(-90))
        .frame(width: 80, height: 80)
        .gesture(
            LongPressGesture(minimumDuration: 1.2)
                .updating($isPressed) { value, state, _ in state = value }
        )
        .onChange(of: pressProgress) { _, newValue in
            timerBucket = Int(newValue * 4) // 4단계로 나눔
        }
        .sensoryFeedback(.selection, trigger: timerBucket)
        .sensoryFeedback(.success, trigger: pressProgress) { _, new in new >= 1.0 }
}

@State private var volume: Double = 0.5

var body: some View {
    Slider(value: $volume, in: 0...1, step: 0.1)
        .sensoryFeedback(.increase, trigger: volume) { old, new in new > old }
        .sensoryFeedback(.decrease, trigger: volume) { old, new in new < old }
}