🎬 애니메이션, 왜 중요할까?

📱 UIView 애니메이션 - 시작은 간단하게!

🎨 기본 UIView 애니메이션 메서드

UIView.animate(withDuration: 0.3) {
    // 애니메이션할 속성 변경
    myView.alpha = 0.5
    myView.frame.origin.y += 100
    myView.backgroundColor = .blue
}

UIView.animate(withDuration: 0.5, animations: {
    myView.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)
}) { finished in
    if finished {
        print("애니메이션 완료!")
        // 추가 작업 수행
    }
}

UIView.animate(
    withDuration: 0.8,
    delay: 0.2,
    options: [.curveEaseInOut, .allowUserInteraction],
    animations: {
        myView.center = CGPoint(x: 200, y: 300)
        myView.alpha = 1.0
    },
    completion: { _ in
        print("이동 완료!")
    }
)

🌊 스프링 애니메이션 - 자연스러운 움직임의 비밀

UIView.animate(
    withDuration: 0.6,
    delay: 0,
    usingSpringWithDamping: 0.7,  // 0~1, 낮을수록 더 튕김
    initialSpringVelocity: 0.5,    // 초기 속도
    options: .curveEaseInOut,
    animations: {
        myButton.transform = CGAffineTransform(scaleX: 1.2, y: 1.2)
    },
    completion: nil
)

🎭 애니메이션 가능한 속성들

🎯 실전 예제 - 버튼 탭 애니메이션

@IBAction func buttonTapped(_ sender: UIButton) {
    // 1단계: 버튼을 작게 만들기
    UIView.animate(
        withDuration: 0.1,
        animations: {
            sender.transform = CGAffineTransform(scaleX: 0.95, y: 0.95)
        },
        completion: { _ in
            // 2단계: 원래 크기로 돌아오기 (스프링 효과)
            UIView.animate(
                withDuration: 0.3,
                delay: 0,
                usingSpringWithDamping: 0.5,
                initialSpringVelocity: 0.5,
                options: [],
                animations: {
                    sender.transform = .identity
                },
                completion: nil
            )
        }
    )
    
    // 실제 버튼 기능 수행
    performButtonAction()
}

⚡ Core Animation - 더 강력한 애니메이션의 세계

🎨 CALayer - 애니메이션의 실제 주인공

// UIView의 레이어에 접근하기
let myView = UIView()
let layer = myView.layer

// 레이어 속성 변경
layer.cornerRadius = 10
layer.borderWidth = 2
layer.borderColor = UIColor.blue.cgColor
layer.shadowOpacity = 0.5
layer.shadowRadius = 5

🎬 CABasicAnimation - 기본 애니메이션

// 위치 이동 애니메이션
let animation = CABasicAnimation(keyPath: "position.x")
animation.fromValue = 50
animation.toValue = 300
animation.duration = 1.0
animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)

myView.layer.add(animation, forKey: "moveX")

// 애니메이션 후 실제 위치도 변경해야 함!
myView.layer.position.x = 300

🌈 애니메이션 가능한 CALayer 속성들

🎪 CAKeyframeAnimation - 복잡한 경로 애니메이션

// 흔들림 효과 만들기
let shake = CAKeyframeAnimation(keyPath: "transform.rotation")
shake.values = [0, -0.1, 0.1, -0.1, 0.1, 0]  // 라디안 값
shake.keyTimes = [0, 0.2, 0.4, 0.6, 0.8, 1.0]
shake.duration = 0.5

myView.layer.add(shake, forKey: "shake")

// 경로를 따라 이동하는 애니메이션
let path = UIBezierPath()
path.move(to: CGPoint(x: 50, y: 50))
path.addCurve(
    to: CGPoint(x: 300, y: 300),
    controlPoint1: CGPoint(x: 100, y: 200),
    controlPoint2: CGPoint(x: 250, y: 100)
)

let pathAnimation = CAKeyframeAnimation(keyPath: "position")
pathAnimation.path = path.cgPath
pathAnimation.duration = 2.0
pathAnimation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)

myView.layer.add(pathAnimation, forKey: "movePath")

🎭 CAAnimationGroup - 여러 애니메이션 동시에!

// 이동 애니메이션
let move = CABasicAnimation(keyPath: "position")
move.toValue = CGPoint(x: 200, y: 200)

// 회전 애니메이션
let rotate = CABasicAnimation(keyPath: "transform.rotation")
rotate.toValue = CGFloat.pi * 2

// 크기 애니메이션
let scale = CABasicAnimation(keyPath: "transform.scale")
scale.toValue = 1.5

// 투명도 애니메이션
let fade = CABasicAnimation(keyPath: "opacity")
fade.toValue = 0.3

// 그룹으로 묶기
let group = CAAnimationGroup()
group.animations = [move, rotate, scale, fade]
group.duration = 2.0
group.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)

myView.layer.add(group, forKey: "complexAnimation")

// 실제 값도 변경
myView.layer.position = CGPoint(x: 200, y: 200)
myView.layer.transform = CATransform3DMakeScale(1.5, 1.5, 1.0)
myView.layer.opacity = 0.3

🎯 실전 테크닉 - 프로처럼 애니메이션하기

⏱️ 타이밍 함수의 마법

// UIView 애니메이션에서 타이밍 함수 사용
UIView.animate(
    withDuration: 0.5,
    delay: 0,
    options: .curveEaseInOut,  // 타이밍 함수 옵션
    animations: {
        myView.center.y += 100
    }
)

// Core Animation에서 커스텀 타이밍 함수
let animation = CABasicAnimation(keyPath: "position.y")
animation.toValue = 300
animation.duration = 0.5

// 베지어 곡선으로 커스텀 타이밍 만들기
animation.timingFunction = CAMediaTimingFunction(
    controlPoints: 0.25, 0.1, 0.25, 1.0
)

myView.layer.add(animation, forKey: "customTiming")

🎪 체이닝 애니메이션 - 순차적 실행

// 1단계: 위로 이동
UIView.animate(withDuration: 0.3, animations: {
    self.myView.center.y -= 50
}) { _ in
    // 2단계: 회전
    UIView.animate(withDuration: 0.5, animations: {
        self.myView.transform = CGAffineTransform(rotationAngle: .pi)
    }) { _ in
        // 3단계: 원래 위치로
        UIView.animate(withDuration: 0.3, animations: {
            self.myView.center.y += 50
            self.myView.transform = .identity
        })
    }
}

// UIViewPropertyAnimator로 더 깔끔하게
let animator1 = UIViewPropertyAnimator(duration: 0.3, curve: .easeOut) {
    self.myView.center.y -= 50
}

animator1.addCompletion { _ in
    let animator2 = UIViewPropertyAnimator(duration: 0.5, curve: .easeInOut) {
        self.myView.transform = CGAffineTransform(rotationAngle: .pi)
    }
    
    animator2.addCompletion { _ in
        let animator3 = UIViewPropertyAnimator(duration: 0.3, curve: .easeIn) {
            self.myView.center.y += 50
            self.myView.transform = .identity
        }
        animator3.startAnimation()
    }
    
    animator2.startAnimation()
}

animator1.startAnimation()

🎮 인터랙티브 애니메이션 - 사용자가 제어하는 애니메이션

class InteractiveViewController: UIViewController {
    var animator: UIViewPropertyAnimator?
    let cardView = UIView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupGesture()
    }
    
    func setupGesture() {
        let pan = UIPanGestureRecognizer(target: self, action: #selector(handlePan))
        cardView.addGestureRecognizer(pan)
    }
    
    @objc func handlePan(_ gesture: UIPanGestureRecognizer) {
        let translation = gesture.translation(in: view)
        let progress = translation.y / view.bounds.height
        
        switch gesture.state {
        case .began:
            // 애니메이터 생성 (자동 시작 안 함)
            animator = UIViewPropertyAnimator(duration: 0.5, curve: .easeOut) {
                self.cardView.transform = CGAffineTransform(scaleX: 1.2, y: 1.2)
                self.cardView.center.y += 200
            }
            animator?.pauseAnimation()  // 일시정지 상태로 시작
            
        case .changed:
            // 드래그 진행도에 따라 애니메이션 진행
            animator?.fractionComplete = max(0, min(1, progress))
            
        case .ended:
            let velocity = gesture.velocity(in: view).y
            
            if velocity > 0 && progress > 0.5 {
                // 아래로 빠르게 드래그 → 애니메이션 완료
                animator?.continueAnimation(withTimingParameters: nil, durationFactor: 0)
            } else {
                // 그 외 → 원래대로 되돌림
                animator?.isReversed = true
                animator?.continueAnimation(withTimingParameters: nil, durationFactor: 0)
            }
            
        default:
            break
        }
    }
}

🌟 페이드 인/아웃 - 가장 많이 쓰는 애니메이션

// 페이드 인
func fadeIn(view: UIView, duration: TimeInterval = 0.3) {
    view.alpha = 0
    view.isHidden = false
    
    UIView.animate(withDuration: duration) {
        view.alpha = 1
    }
}

// 페이드 아웃
func fadeOut(view: UIView, duration: TimeInterval = 0.3, completion: (() -> Void)? = nil) {
    UIView.animate(withDuration: duration, animations: {
        view.alpha = 0
    }) { _ in
        view.isHidden = true
        completion?()
    }
}

// 크로스 페이드 (한 뷰는 사라지고 다른 뷰는 나타남)
func crossFade(from: UIView, to: UIView, duration: TimeInterval = 0.3) {
    to.alpha = 0
    to.isHidden = false
    
    UIView.animate(withDuration: duration) {
        from.alpha = 0
        to.alpha = 1
    } completion: { _ in
        from.isHidden = true
    }
}

🎯 로딩 인디케이터 만들기

class CustomLoadingView: UIView {
    private let circleLayer = CAShapeLayer()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupCircle()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupCircle()
    }
    
    private func setupCircle() {
        // 원형 경로 만들기
        let center = CGPoint(x: bounds.midX, y: bounds.midY)
        let radius = min(bounds.width, bounds.height) / 2 - 10
        let path = UIBezierPath(
            arcCenter: center,
            radius: radius,
            startAngle: 0,
            endAngle: .pi * 1.5,
            clockwise: true
        )
        
        // 레이어 설정
        circleLayer.path = path.cgPath
        circleLayer.fillColor = UIColor.clear.cgColor
        circleLayer.strokeColor = UIColor.systemBlue.cgColor
        circleLayer.lineWidth = 4
        circleLayer.lineCap = .round
        
        layer.addSublayer(circleLayer)
    }
    
    func startAnimating() {
        // 회전 애니메이션
        let rotation = CABasicAnimation(keyPath: "transform.rotation")
        rotation.fromValue = 0
        rotation.toValue = CGFloat.pi * 2
        rotation.duration = 1.0
        rotation.repeatCount = .infinity
        
        circleLayer.add(rotation, forKey: "rotationAnimation")
    }
    
    func stopAnimating() {
        circleLayer.removeAllAnimations()
    }
}

🚀 성능 최적화 - 부드러운 60fps 유지하기

⚡ 성능 최적화 팁들

// ✅ 좋은 예: transform 사용 (GPU 가속)
UIView.animate(withDuration: 0.3) {
    myView.transform = CGAffineTransform(translationX: 100, y: 0)
}

// ❌ 나쁜 예: frame 직접 변경 (CPU 사용)
UIView.animate(withDuration: 0.3) {
    var frame = myView.frame
    frame.origin.x += 100
    myView.frame = frame
}

// ❌ 느린 방법: 자동 그림자 경로 계산
layer.shadowOpacity = 0.5
layer.shadowRadius = 5

// ✅ 빠른 방법: 그림자 경로 미리 지정
layer.shadowOpacity = 0.5
layer.shadowRadius = 5
layer.shadowPath = UIBezierPath(rect: layer.bounds).cgPath

// 더 나은 방법: 래스터화 사용
layer.shadowOpacity = 0.5
layer.shadowRadius = 5
layer.shadowPath = UIBezierPath(rect: layer.bounds).cgPath
layer.shouldRasterize = true
layer.rasterizationScale = UIScreen.main.scale

// ❌ 느릴 수 있는 방법
imageView.layer.cornerRadius = 10
imageView.layer.masksToBounds = true

// ✅ 더 나은 방법: 이미지를 미리 둥글게 만들기
extension UIImage {
    func rounded(cornerRadius: CGFloat) -> UIImage? {
        UIGraphicsBeginImageContextWithOptions(size, false, scale)
        defer { UIGraphicsEndImageContext() }
        
        let rect = CGRect(origin: .zero, size: size)
        UIBezierPath(roundedRect: rect, cornerRadius: cornerRadius).addClip()
        draw(in: rect)
        
        return UIGraphicsGetImageFromCurrentImageContext()
    }
}

// 사용
imageView.image = originalImage.rounded(cornerRadius: 10)

// ❌ 느린 방법
UIView.animate(withDuration: 0.3) {
    self.view.layoutIfNeeded()  // 전체 레이아웃 재계산
}

// ✅ 더 나은 방법: 필요한 뷰만 애니메이션
UIView.animate(withDuration: 0.3) {
    myView.transform = CGAffineTransform(translationX: 100, y: 0)
}

🔍 성능 측정하기

🎨 실전 프로젝트 - 카드 스와이프 애니메이션

class SwipeableCardView: UIView {
    // MARK: - Properties
    private var originalCenter: CGPoint = .zero
    private let threshold: CGFloat = 100  // 스와이프 임계값
    
    // 카드 제거 콜백
    var onSwipeLeft: (() -> Void)?
    var onSwipeRight: (() -> Void)?
    
    // MARK: - Initialization
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupView()
        setupGesture()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupView()
        setupGesture()
    }
    
    // MARK: - Setup
    private func setupView() {
        // 카드 스타일 설정
        backgroundColor = .white
        layer.cornerRadius = 12
        layer.shadowColor = UIColor.black.cgColor
        layer.shadowOpacity = 0.2
        layer.shadowOffset = CGSize(width: 0, height: 2)
        layer.shadowRadius = 8
        
        // 성능 최적화
        layer.shadowPath = UIBezierPath(
            roundedRect: bounds,
            cornerRadius: layer.cornerRadius
        ).cgPath
    }
    
    private func setupGesture() {
        let pan = UIPanGestureRecognizer(target: self, action: #selector(handlePan))
        addGestureRecognizer(pan)
    }
    
    // MARK: - Gesture Handling
    @objc private func handlePan(_ gesture: UIPanGestureRecognizer) {
        let translation = gesture.translation(in: superview)
        let velocity = gesture.velocity(in: superview)
        
        switch gesture.state {
        case .began:
            originalCenter = center
            
            // 카드를 살짝 확대
            UIView.animate(withDuration: 0.2) {
                self.transform = CGAffineTransform(scaleX: 1.05, y: 1.05)
            }
            
        case .changed:
            // 카드 이동
            center = CGPoint(
                x: originalCenter.x + translation.x,
                y: originalCenter.y + translation.y
            )
            
            // 회전 효과 (이동 거리에 비례)
            let rotationAngle = translation.x / 500
            let rotationTransform = CGAffineTransform(rotationAngle: rotationAngle)
            let scaleTransform = CGAffineTransform(scaleX: 1.05, y: 1.05)
            transform = rotationTransform.concatenating(scaleTransform)
            
            // 투명도 조절 (멀리 갈수록 투명해짐)
            let distance = abs(translation.x)
            alpha = 1 - (distance / 300)
            
        case .ended:
            // 스와이프 판정
            let shouldSwipe = abs(translation.x) > threshold || abs(velocity.x) > 1000
            
            if shouldSwipe {
                // 스와이프 완료
                let direction: CGFloat = translation.x > 0 ? 1 : -1
                swipeAway(direction: direction)
            } else {
                // 원래 위치로 복귀
                resetPosition()
            }
            
        default:
            resetPosition()
        }
    }
    
    // MARK: - Animations
    private func swipeAway(direction: CGFloat) {
        let offScreenX = (superview?.bounds.width ?? 0) * 1.5 * direction
        
        UIView.animate(
            withDuration: 0.4,
            delay: 0,
            usingSpringWithDamping: 0.8,
            initialSpringVelocity: 0.5,
            options: .curveEaseOut,
            animations: {
                self.center.x = self.originalCenter.x + offScreenX
                self.alpha = 0
                
                // 회전 증가
                let rotation = CGFloat.pi / 4 * direction
                self.transform = CGAffineTransform(rotationAngle: rotation)
            },
            completion: { _ in
                // 콜백 실행
                if direction > 0 {
                    self.onSwipeRight?()
                } else {
                    self.onSwipeLeft?()
                }
                
                self.removeFromSuperview()
            }
        )
    }
    
    private func resetPosition() {
        UIView.animate(
            withDuration: 0.5,
            delay: 0,
            usingSpringWithDamping: 0.6,
            initialSpringVelocity: 0.5,
            options: .curveEaseOut,
            animations: {
                self.center = self.originalCenter
                self.transform = .identity
                self.alpha = 1
            }
        )
    }
    
    // MARK: - Public Methods
    func swipeRight() {
        swipeAway(direction: 1)
    }
    
    func swipeLeft() {
        swipeAway(direction: -1)
    }
}

🎯 사용 예제

class CardViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        setupCards()
    }
    
    private func setupCards() {
        let cardView = SwipeableCardView(frame: CGRect(
            x: 50,
            y: 200,
            width: view.bounds.width - 100,
            height: 400
        ))
        
        // 카드 내용 추가
        let imageView = UIImageView(image: UIImage(named: "profile"))
        imageView.frame = cardView.bounds
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        cardView.addSubview(imageView)
        
        // 스와이프 콜백 설정
        cardView.onSwipeRight = { [weak self] in
            print("좋아요! ❤️")
            self?.loadNextCard()
        }
        
        cardView.onSwipeLeft = { [weak self] in
            print("별로... 👎")
            self?.loadNextCard()
        }
        
        view.addSubview(cardView)
    }
    
    private func loadNextCard() {
        // 다음 카드 로드
        print("다음 카드 로딩...")
    }
}

🎓 고급 테크닉 - 더 깊이 들어가기

🎭 CADisplayLink - 프레임 단위 제어

class CustomAnimationView: UIView {
    private var displayLink: CADisplayLink?
    private var startTime: CFTimeInterval = 0
    private let duration: CFTimeInterval = 2.0
    
    func startAnimation() {
        startTime = CACurrentMediaTime()
        
        displayLink = CADisplayLink(target: self, selector: #selector(updateAnimation))
        displayLink?.add(to: .main, forMode: .common)
    }
    
    @objc private func updateAnimation() {
        let elapsed = CACurrentMediaTime() - startTime
        let progress = min(elapsed / duration, 1.0)
        
        // 커스텀 이징 함수 적용
        let easedProgress = easeInOutCubic(progress)
        
        // 애니메이션 업데이트
        layer.position.x = 50 + (300 * easedProgress)
        
        // 완료 체크
        if progress >= 1.0 {
            displayLink?.invalidate()
            displayLink = nil
        }
    }
    
    // 커스텀 이징 함수
    private func easeInOutCubic(_ t: Double) -> Double {
        if t < 0.5 {
            return 4 * t * t * t
        } else {
            let f = 2 * t - 2
            return 0.5 * f * f * f + 1
        }
    }
    
    deinit {
        displayLink?.invalidate()
    }
}

🌊 CATransaction - 암시적 애니메이션 제어

// 암시적 애니메이션 비활성화
CATransaction.begin()
CATransaction.setDisableActions(true)
layer.backgroundColor = UIColor.red.cgColor
CATransaction.commit()

// 암시적 애니메이션 커스터마이징
CATransaction.begin()
CATransaction.setAnimationDuration(0.5)
CATransaction.setAnimationTimingFunction(
    CAMediaTimingFunction(name: .easeInEaseOut)
)
CATransaction.setCompletionBlock {
    print("애니메이션 완료!")
}

layer.cornerRadius = 20
layer.backgroundColor = UIColor.blue.cgColor

CATransaction.commit()

🎨 CAGradientLayer - 그라디언트 애니메이션

class GradientAnimationView: UIView {
    private let gradientLayer = CAGradientLayer()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupGradient()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupGradient()
    }
    
    private func setupGradient() {
        gradientLayer.frame = bounds
        gradientLayer.colors = [
            UIColor.systemBlue.cgColor,
            UIColor.systemPurple.cgColor
        ]
        gradientLayer.startPoint = CGPoint(x: 0, y: 0)
        gradientLayer.endPoint = CGPoint(x: 1, y: 1)
        
        layer.addSublayer(gradientLayer)
    }
    
    func animateColors() {
        let animation = CABasicAnimation(keyPath: "colors")
        animation.fromValue = gradientLayer.colors
        animation.toValue = [
            UIColor.systemPink.cgColor,
            UIColor.systemOrange.cgColor
        ]
        animation.duration = 2.0
        animation.autoreverses = true
        animation.repeatCount = .infinity
        
        gradientLayer.add(animation, forKey: "colorChange")
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        gradientLayer.frame = bounds
    }
}

🎯 CAShapeLayer - 경로 애니메이션

class DrawingAnimationView: UIView {
    private let shapeLayer = CAShapeLayer()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupShape()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupShape()
    }
    
    private func setupShape() {
        // 하트 모양 경로 만들기
        let path = createHeartPath()
        
        shapeLayer.path = path.cgPath
        shapeLayer.strokeColor = UIColor.systemPink.cgColor
        shapeLayer.fillColor = UIColor.clear.cgColor
        shapeLayer.lineWidth = 3
        shapeLayer.lineCap = .round
        shapeLayer.lineJoin = .round
        
        layer.addSublayer(shapeLayer)
    }
    
    private func createHeartPath() -> UIBezierPath {
        let path = UIBezierPath()
        let width = bounds.width
        let height = bounds.height
        
        // 하트 모양 그리기 (간단한 버전)
        path.move(to: CGPoint(x: width/2, y: height * 0.3))
        path.addCurve(
            to: CGPoint(x: width/2, y: height * 0.8),
            controlPoint1: CGPoint(x: width * 0.2, y: height * 0.5),
            controlPoint2: CGPoint(x: width * 0.2, y: height * 0.7)
        )
        path.addCurve(
            to: CGPoint(x: width/2, y: height * 0.3),
            controlPoint1: CGPoint(x: width * 0.8, y: height * 0.7),
            controlPoint2: CGPoint(x: width * 0.8, y: height * 0.5)
        )
        
        return path
    }
    
    func animateDrawing() {
        // 그려지는 애니메이션
        let animation = CABasicAnimation(keyPath: "strokeEnd")
        animation.fromValue = 0
        animation.toValue = 1
        animation.duration = 2.0
        animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
        
        shapeLayer.add(animation, forKey: "drawAnimation")
    }
    
    func animateFill() {
        // 채워지는 애니메이션
        shapeLayer.fillColor = UIColor.systemPink.cgColor
        
        let animation = CABasicAnimation(keyPath: "fillColor")
        animation.fromValue = UIColor.clear.cgColor
        animation.toValue = UIColor.systemPink.cgColor
        animation.duration = 0.5
        
        shapeLayer.add(animation, forKey: "fillAnimation")
    }
}

💡 실무 팁과 베스트 프랙티스

📱 접근성 고려하기

// 애니메이션 감소 설정 확인
if UIAccessibility.isReduceMotionEnabled {
    // 애니메이션 없이 즉시 변경
    myView.alpha = 0
} else {
    // 일반 애니메이션
    UIView.animate(withDuration: 0.3) {
        myView.alpha = 0
    }
}

// 더 나은 방법: 확장 함수로 만들기
extension UIView {
    func animateIfAllowed(
        duration: TimeInterval,
        animations: @escaping () -> Void,
        completion: ((Bool) -> Void)? = nil
    ) {
        if UIAccessibility.isReduceMotionEnabled {
            animations()
            completion?(true)
        } else {
            UIView.animate(
                withDuration: duration,
                animations: animations,
                completion: completion
            )
        }
    }
}

// 사용
myView.animateIfAllowed(duration: 0.3) {
    myView.alpha = 0
}

⚡ 배터리 효율 고려하기

class BatteryEfficientViewController: UIViewController {
    private var animator: UIViewPropertyAnimator?
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        startAnimations()
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        stopAnimations()
    }
    
    private func startAnimations() {
        // 애니메이션 시작
        animator = UIViewPropertyAnimator.runningPropertyAnimator(
            withDuration: 2.0,
            delay: 0,
            options: [.repeat, .autoreverse],
            animations: {
                self.pulsingView.transform = CGAffineTransform(scaleX: 1.1, y: 1.1)
            }
        )
    }
    
    private func stopAnimations() {
        // 화면이 사라질 때 애니메이션 중지
        animator?.stopAnimation(true)
        animator = nil
    }
}

🎯 애니메이션 타이밍 가이드

🔧 디버깅과 테스트

// 디버그용 애니메이션 속도 조절
#if DEBUG
extension UIView {
    static var debugAnimationSpeed: CGFloat = 1.0
    
    static func debugAnimate(
        withDuration duration: TimeInterval,
        animations: @escaping () -> Void,
        completion: ((Bool) -> Void)? = nil
    ) {
        let adjustedDuration = duration * debugAnimationSpeed
        animate(
            withDuration: adjustedDuration,
            animations: animations,
            completion: completion
        )
    }
}
#endif

🎨 재사용 가능한 애니메이션 만들기

// 애니메이션 유틸리티 클래스
enum AnimationStyle {
    case bounce
    case fade
    case slide
    case scale
}

class AnimationHelper {
    // 바운스 애니메이션
    static func bounce(view: UIView, completion: (() -> Void)? = nil) {
        UIView.animate(
            withDuration: 0.1,
            animations: {
                view.transform = CGAffineTransform(scaleX: 0.95, y: 0.95)
            },
            completion: { _ in
                UIView.animate(
                    withDuration: 0.3,
                    delay: 0,
                    usingSpringWithDamping: 0.5,
                    initialSpringVelocity: 0.5,
                    options: [],
                    animations: {
                        view.transform = .identity
                    },
                    completion: { _ in
                        completion?()
                    }
                )
            }
        )
    }
    
    // 페이드 인 애니메이션
    static func fadeIn(view: UIView, duration: TimeInterval = 0.3, completion: (() -> Void)? = nil) {
        view.alpha = 0
        view.isHidden = false
        
        UIView.animate(
            withDuration: duration,
            animations: {
                view.alpha = 1
            },
            completion: { _ in
                completion?()
            }
        )
    }
    
    // 슬라이드 인 애니메이션
    static func slideIn(
        view: UIView,
        from direction: UIRectEdge,
        duration: TimeInterval = 0.4,
        completion: (() -> Void)? = nil
    ) {
        let originalTransform = view.transform
        
        // 시작 위치 설정
        switch direction {
        case .left:
            view.transform = CGAffineTransform(translationX: -view.bounds.width, y: 0)
        case .right:
            view.transform = CGAffineTransform(translationX: view.bounds.width, y: 0)
        case .top:
            view.transform = CGAffineTransform(translationX: 0, y: -view.bounds.height)
        case .bottom:
            view.transform = CGAffineTransform(translationX: 0, y: view.bounds.height)
        default:
            break
        }
        
        view.isHidden = false
        
        UIView.animate(
            withDuration: duration,
            delay: 0,
            usingSpringWithDamping: 0.8,
            initialSpringVelocity: 0.5,
            options: .curveEaseOut,
            animations: {
                view.transform = originalTransform
            },
            completion: { _ in
                completion?()
            }
        )
    }
    
    // 스케일 애니메이션
    static func scale(
        view: UIView,
        to scale: CGFloat,
        duration: TimeInterval = 0.3,
        completion: (() -> Void)? = nil
    ) {
        UIView.animate(
            withDuration: duration,
            delay: 0,
            usingSpringWithDamping: 0.7,
            initialSpringVelocity: 0.5,
            options: .curveEaseInOut,
            animations: {
                view.transform = CGAffineTransform(scaleX: scale, y: scale)
            },
            completion: { _ in
                completion?()
            }
        )
    }
}

// 사용 예제
AnimationHelper.bounce(view: myButton) {
    print("바운스 완료!")
}

AnimationHelper.slideIn(view: menuView, from: .left) {
    print("메뉴 표시 완료!")
}

🎓 마무리하며