🎤 ShazamKit

⭐ Difficulty: ⭐⭐ ⏱️ Est. Time: 1-2h 📂 Graphics & Media

오디오 인식 및 음악 매칭 프레임워크

iOS 15+오디오 인식

✨ ShazamKit is?

ShazamKit is a framework that integrates Shazam's audio recognition technology into your app. It recognizes playing music in real-time, creates custom audio catalogs for in-app content matching, and accesses Shazam's vast music database. Useful for delivering audio-based experiences in music apps, games, educational apps and more.

💡 Key Features: Music Recognition · Custom Catalogs · Real-Time Matching · Shazam Library Access · Audio Signature Generation · Offline Recognition

🎵 1. 기본 음악 인식

Use SHSession to recognize music from the Shazam catalog.

ShazamManager.swift — Basic Music Recognition

import ShazamKit
import AVFoundation
import SwiftUI

@Observable
class ShazamManager: NSObject, SHSessionDelegate {
    private var session: SHSession?
    private var audioEngine: AVAudioEngine?

    var matchedMedia: SHMatchedMediaItem?
    var isListening = false
    var errorMessage: String?

    override init() {
        super.init()
        setupSession()
    }

    // 세션 설정
    private func setupSession() {
        // Shazam 카탈로그 세션 생성
        session = SHSession()
        session?.delegate = self
        print("✅ Shazam 세션 생성됨")
    }

    // 음악 인식 시작
    func startListening() {
        guard !isListening else { return }

        do {
            // 오디오 세션 설정
            let audioSession = AVAudioSession.sharedInstance()
            try audioSession.setCategory(.record)
            try audioSession.setActive(true)

            // 오디오 엔진 설정
            audioEngine = AVAudioEngine()
            guard let audioEngine = audioEngine else { return }

            let inputNode = audioEngine.inputNode
            let bus = 0
            let bufferSize: AVAudioFrameCount = 2048

            // 오디오 탭 설치
            inputNode.installTap(onBus: bus, bufferSize: bufferSize, format: inputNode.outputFormat(forBus: bus)) { [weak self] buffer, time in
                self?.session?.matchStreamingBuffer(buffer, at: time)
            }

            // 오디오 엔진 시작
            try audioEngine.start()

            isListening = true
            errorMessage = nil
            print("🎤 음악 인식 시작")
        } catch {
            errorMessage = "오디오 엔진 시작 실패: \(error.localizedDescription)"
            print("❌ \(errorMessage ?? "")")
        }
    }

    // 음악 인식 중지
    func stopListening() {
        guard isListening else { return }

        audioEngine?.stop()
        audioEngine?.inputNode.removeTap(onBus: 0)
        audioEngine = nil

        isListening = false
        print("⏹️ 음악 인식 중지")
    }

    // MARK: - SHSessionDelegate

    func session(_ session: SHSession, didFind match: SHMatch) {
        guard let mediaItem = match.mediaItems.first else { return }

        Task { @MainActor in
            matchedMedia = mediaItem
            print("🎵 발견: \(mediaItem.title ?? "Unknown") - \(mediaItem.artist ?? "Unknown")")
        }
    }

    func session(_ session: SHSession, didNotFindMatchFor signature: SHSignature, error: Error?) {
        Task { @MainActor in
            errorMessage = "음악을 찾을 수 없습니다"
            print("❌ 매칭 실패")
        }
    }
}

📦 2. 오디오 파일 인식

저장된 오디오 파일에서 음악을 인식.

AudioFileRecognition.swift — File Recognition

import ShazamKit
import AVFoundation

extension ShazamManager {
    // 오디오 파일에서 시그니처 생성
    func generateSignature(from url: URL) async throws -> SHSignature {
        // 오디오 파일 읽기
        let file = try AVAudioFile(forReading: url)

        // 시그니처 생성기
        let generator = SHSignatureGenerator()

        // 버퍼 읽기 및 시그니처 생성
        let bufferSize: AVAudioFrameCount = 2048
        guard let buffer = AVAudioPCMBuffer(
            pcmFormat: file.processingFormat,
            frameCapacity: bufferSize
        ) else {
            throw NSError(domain: "AudioError", code: -1)
        }

        while file.framePosition < file.length {
            try file.read(into: buffer)
            try generator.append(buffer, at: nil)
        }

        // 시그니처 반환
        return generator.signature()
    }

    // 파일에서 음악 인식
    func recognizeAudioFile(at url: URL) async {
        do {
            // 시그니처 생성
            let signature = try await generateSignature(from: url)

            // Shazam 카탈로그에서 매칭
            let match = try await session?.match(signature)

            if let mediaItem = match?.mediaItems.first {
                matchedMedia = mediaItem
                print("🎵 파일 인식 성공: \(mediaItem.title ?? "Unknown")")
            }
        } catch {
            errorMessage = "파일 인식 실패: \(error.localizedDescription)"
            print("❌ \(errorMessage ?? "")")
        }
    }
}

🗂️ 3. 커스텀 카탈로그

Create your own audio catalog to recognize in-app content.

CustomCatalog.swift — Custom Catalog

import ShazamKit
import AVFoundation

@Observable
class CustomCatalogManager: NSObject, SHSessionDelegate {
    private var session: SHSession?
    private var catalog: SHCustomCatalog?

    var matchedReference: SHMediaItem?
    var isListening = false

    // 커스텀 카탈로그 생성
    func createCustomCatalog(from audioFiles: [URL]) async throws {
        var referenceSignatures: [SHSignature] = []

        // 각 오디오 파일에서 시그니처 생성
        for (index, fileURL) in audioFiles.enumerated() {
            let file = try AVAudioFile(forReading: fileURL)
            let generator = SHSignatureGenerator()

            let bufferSize: AVAudioFrameCount = 2048
            guard let buffer = AVAudioPCMBuffer(
                pcmFormat: file.processingFormat,
                frameCapacity: bufferSize
            ) else { continue }

            while file.framePosition < file.length {
                try file.read(into: buffer)
                try generator.append(buffer, at: nil)
            }

            let signature = generator.signature()
            referenceSignatures.append(signature)

            print("✅ 시그니처 생성: \(fileURL.lastPathComponent)")
        }

        // 미디어 아이템 생성
        var mediaItems: [SHMediaItem] = []
        for (index, signature) in referenceSignatures.enumerated() {
            let mediaItem = SHMediaItem(
                properties: [
                    .title: "Track \(index + 1)",
                    .artist: "Custom Artist"
                ]
            )
            mediaItems.append(mediaItem)
        }

        // 커스텀 카탈로그 생성
        catalog = SHCustomCatalog()

        for (signature, mediaItem) in zip(referenceSignatures, mediaItems) {
            try await catalog?.addReferenceSignature(signature, representing: [mediaItem])
        }

        // 커스텀 카탈로그 세션 생성
        if let catalog = catalog {
            session = SHSession(catalog: catalog)
            session?.delegate = self
            print("✅ 커스텀 카탈로그 생성 완료")
        }
    }

    // 커스텀 카탈로그에서 매칭
    func matchAgainstCustomCatalog(signature: SHSignature) async {
        guard let session = session else { return }

        do {
            let match = try await session.match(signature)
            if let mediaItem = match.mediaItems.first {
                matchedReference = mediaItem
                print("🎵 커스텀 카탈로그 매칭: \(mediaItem.title ?? "Unknown")")
            }
        } catch {
            print("❌ 커스텀 매칭 실패: \(error)")
        }
    }

    // MARK: - SHSessionDelegate

    func session(_ session: SHSession, didFind match: SHMatch) {
        guard let mediaItem = match.mediaItems.first else { return }

        Task { @MainActor in
            matchedReference = mediaItem
            print("🎵 커스텀 매칭 성공")
        }
    }

    func session(_ session: SHSession, didNotFindMatchFor signature: SHSignature, error: Error?) {
        print("❌ 커스텀 매칭 실패")
    }
}

💾 4. 시그니처 저장 및 로드

Save generated signatures to file for later reuse.

SignatureStorage.swift — Signature Management

import ShazamKit
import Foundation

class SignatureStorage {
    // 시그니처를 파일로 저장
    func saveSignature(_ signature: SHSignature, to fileName: String) throws {
        // 시그니처 데이터
        let data = signature.dataRepresentation

        // 저장 경로
        let url = FileManager.default
            .urls(for: .documentDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("\(fileName).shazamsignature")

        // 파일 저장
        try data.write(to: url)
        print("✅ 시그니처 저장: \(url)")
    }

    // 파일에서 시그니처 로드
    func loadSignature(from fileName: String) throws -> SHSignature {
        // 파일 경로
        let url = FileManager.default
            .urls(for: .documentDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("\(fileName).shazamsignature")

        // 데이터 읽기
        let data = try Data(contentsOf: url)

        // 시그니처 생성
        let signature = try SHSignature(dataRepresentation: data)
        print("✅ 시그니처 로드: \(url)")

        return signature
    }

    // 저장된 모든 시그니처 목록
    func listSavedSignatures() -> [String] {
        let documentsURL = FileManager.default
            .urls(for: .documentDirectory, in: .userDomainMask)[0]

        do {
            let files = try FileManager.default
                .contentsOfDirectory(at: documentsURL, includingPropertiesForKeys: nil)
                .filter { $0.pathExtension == "shazamsignature" }
                .map { $0.deletingPathExtension().lastPathComponent }

            return files
        } catch {
            print("❌ 파일 목록 가져오기 실패: \(error)")
            return []
        }
    }

    // 시그니처 삭제
    func deleteSignature(fileName: String) throws {
        let url = FileManager.default
            .urls(for: .documentDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("\(fileName).shazamsignature")

        try FileManager.default.removeItem(at: url)
        print("✅ 시그니처 삭제: \(fileName)")
    }
}

📱 Complete Example

ShazamAppView.swift — Shazam App

import SwiftUI
import ShazamKit

struct ShazamAppView: View {
    @State private var shazamManager = ShazamManager()
    @State private var showingResult = false

    var body: some View {
        NavigationStack {
            VStack(spacing: 30) {
                // 버튼
                Button {
                    if shazamManager.isListening {
                        shazamManager.stopListening()
                    } else {
                        shazamManager.startListening()
                    }
                } label: {
                    ZStack {
                        Circle()
                            .fill(shazamManager.isListening ? Color.red : Color.blue)
                            .frame(width: 150, height: 150)

                        if shazamManager.isListening {
                            Image(systemName: "waveform.circle.fill")
                                .font(.system(size: 60))
                                .foregroundStyle(.white)
                        } else {
                            Image(systemName: "magnifyingglass")
                                .font(.system(size: 60))
                                .foregroundStyle(.white)
                        }
                    }
                }
                .buttonStyle(.plain)

                Text(shazamManager.isListening ? "인식 중..." : "탭하여 음악 인식")
                    .font(.headline)

                // 결과 표시
                if let media = shazamManager.matchedMedia {
                    VStack(spacing: 12) {
                        AsyncImage(url: media.artworkURL) { image in
                            image
                                .resizable()
                                .scaledToFit()
                        } placeholder: {
                            Rectangle()
                                .fill(Color.gray.opacity(0.3))
                        }
                        .frame(width: 200, height: 200)
                        .cornerRadius(12)

                        VStack(spacing: 4) {
                            Text(media.title ?? "Unknown")
                                .font(.title2)
                                .fontWeight(.bold)

                            Text(media.artist ?? "Unknown Artist")
                                .font(.subheadline)
                                .foregroundStyle(.secondary)
                        }

                        if let appleMusicURL = media.appleMusicURL {
                            Link("Apple Music에서 열기", destination: appleMusicURL)
                                .buttonStyle(.borderedProminent)
                        }

                        if let webURL = media.webURL {
                            Link("웹에서 보기", destination: webURL)
                                .buttonStyle(.bordered)
                        }
                    }
                    .padding()
                }

                // 에러 메시지
                if let error = shazamManager.errorMessage {
                    Text(error)
                        .foregroundStyle(.red)
                        .font(.caption)
                }

                Spacer()
            }
            .padding()
            .navigationTitle("음악 인식")
        }
    }
}

💡 HIG Guidelines

권한: 마이크 권한 필요 (In Info.plist, NSMicrophoneUsageDescription 추가)
피드백: 인식 중임을 명확히 표시
결과 표시: 앨범 아트, 제목, 아티스트를 시각적으로 표시
링크 제공: Apple Music 또는 웹 링크 제공
오프라인: 인터넷 연결 필요 (Shazam 카탈로그 사용 시)

🎯 Practical Usage

Music Apps: 재생 중인 음악 자동 인식
라디오 앱: 방송 중인 음악 식별
Games: 커스텀 카탈로그로 배경 음악 트래킹
Education Apps: 오디오 콘텐츠 진도 추적
Event Apps: 공연 중 곡 정보 제공

📚 Learn More

⚡️ Performance Tips: Custom catalogs can be bundled with the app or downloaded from a server. Signature generation is CPU-intensive, so run it on a background thread. The Shazam catalog requires network, but custom catalogs work offline.

📎 Apple Official Resources

📘 Documentation 🎬 WWDC Sessions