[Release] 1.1.4 업데이트 (#75)

* feat(1.1.3): 버전 업데이트

* feat: 데이터 refetch 추가

* Merge pull request #74 from ApptiveDev/feat/72

feat - QA 반영

Author: mark77234

KillingPart.xcodeproj/project.pbxproj

@@ -434,7 +434,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_ENTITLEMENTS = KillingPart/KillingPart.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 28;
+				CURRENT_PROJECT_VERSION = 30;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = GQ89YG5G9R;
 				ENABLE_APP_SANDBOX = YES;
@@ -459,7 +459,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "@executable_path/Frameworks";
 				"LD_RUNPATH_SEARCH_PATHS[sdk=macosx*]" = "@executable_path/../Frameworks";
 				MACOSX_DEPLOYMENT_TARGET = 14.0;
-				MARKETING_VERSION = 1.1.2;
+				MARKETING_VERSION = 1.1.4;
 				PRODUCT_BUNDLE_IDENTIFIER = com.killingpoint.killingpart;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				REGISTER_APP_GROUPS = YES;
@@ -479,7 +479,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_ENTITLEMENTS = KillingPart/KillingPart.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 28;
+				CURRENT_PROJECT_VERSION = 30;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = GQ89YG5G9R;
 				ENABLE_APP_SANDBOX = YES;
@@ -504,7 +504,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "@executable_path/Frameworks";
 				"LD_RUNPATH_SEARCH_PATHS[sdk=macosx*]" = "@executable_path/../Frameworks";
 				MACOSX_DEPLOYMENT_TARGET = 14.0;
-				MARKETING_VERSION = 1.1.2;
+				MARKETING_VERSION = 1.1.4;
 				PRODUCT_BUNDLE_IDENTIFIER = com.killingpoint.killingpart;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				REGISTER_APP_GROUPS = YES;

KillingPart/Services/ITunesService.swift

@@ -40,24 +40,90 @@ struct ITunesService: ITunesServicing {
         let safeLimit = max(limit, 1)
         let safeOffset = max(offset, 0)
         let requestLimit = min(safeOffset + safeLimit, maxResultCount)
+        let searchVariants = makeSearchVariants(from: trimmedQuery)
+        var mergedTracks: [SpotifySimpleTrack] = []
+        var dedupeKeys = Set<String>()
+        var firstFailure: ITunesServiceError?
+        var hasSuccessfulRequest = false
 
-        var components = URLComponents(string: "https://itunes.apple.com/search")
-        components?.queryItems = [
-            URLQueryItem(name: "term", value: trimmedQuery),
+        for variant in searchVariants {
+            do {
+                let rawItems = try await requestTracks(
+                    term: variant.term,
+                    limit: requestLimit,
+                    country: variant.country,
+                    language: variant.language,
+                    attribute: variant.attribute
+                )
+                hasSuccessfulRequest = true
+
+                for item in rawItems {
+                    guard let track = mapToSimpleTrack(item) else { continue }
+                    let dedupeKey = normalizedTrackIdentity(for: track)
+                    guard dedupeKeys.insert(dedupeKey).inserted else { continue }
+                    mergedTracks.append(track)
+                }
+
+                if mergedTracks.count >= requestLimit {
+                    break
+                }
+            } catch let serviceError as ITunesServiceError {
+                if firstFailure == nil {
+                    firstFailure = serviceError
+                }
+            } catch {
+                if firstFailure == nil {
+                    firstFailure = .networkFailure(message: "iTunes 요청 중 네트워크 오류가 발생했어요.")
+                }
+            }
+        }
+
+        if !hasSuccessfulRequest, let firstFailure {
+            throw firstFailure
+        }
+
+        guard safeOffset < mergedTracks.count else {
+            return []
+        }
+
+        return Array(mergedTracks.dropFirst(safeOffset).prefix(safeLimit))
+    }
+
+    private func requestTracks(
+        term: String,
+        limit: Int,
+        country: String?,
+        language: String?,
+        attribute: String?
+    ) async throws -> [ITunesTrackItem] {
+        var queryItems: [URLQueryItem] = [
+            URLQueryItem(name: "term", value: term),
             URLQueryItem(name: "media", value: "music"),
             URLQueryItem(name: "entity", value: "song"),
-            URLQueryItem(name: "country", value: "KR"),
-            URLQueryItem(name: "lang", value: "ko_kr"),
-            URLQueryItem(name: "limit", value: String(requestLimit))
+            URLQueryItem(name: "limit", value: String(limit))
         ]
 
+        if let country, !country.isEmpty {
+            queryItems.append(URLQueryItem(name: "country", value: country))
+        }
+        if let language, !language.isEmpty {
+            queryItems.append(URLQueryItem(name: "lang", value: language))
+        }
+        if let attribute, !attribute.isEmpty {
+            queryItems.append(URLQueryItem(name: "attribute", value: attribute))
+        }
+
+        var components = URLComponents(string: "https://itunes.apple.com/search")
+        components?.queryItems = queryItems
+
         guard let url = components?.url else {
             throw ITunesServiceError.invalidResponse
         }
 
         var request = URLRequest(url: url)
         request.httpMethod = HTTPMethod.get.rawValue
         request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("ko-KR,ko;q=0.9,en-US;q=0.8", forHTTPHeaderField: "Accept-Language")
 
         do {
             let (data, response) = try await session.data(for: request)
@@ -79,19 +145,81 @@ struct ITunesService: ITunesServicing {
                 throw ITunesServiceError.decodingFailed
             }
 
-            let mappedTracks = decoded.results.compactMap(mapToSimpleTrack)
-            guard safeOffset < mappedTracks.count else {
-                return []
-            }
-
-            return Array(mappedTracks.dropFirst(safeOffset).prefix(safeLimit))
+            return decoded.results
         } catch let error as ITunesServiceError {
             throw error
         } catch {
             throw ITunesServiceError.networkFailure(message: "iTunes 요청 중 네트워크 오류가 발생했어요.")
         }
     }
 
+    private func makeSearchVariants(from query: String) -> [SearchVariant] {
+        let normalized = query
+            .components(separatedBy: .whitespacesAndNewlines)
+            .filter { !$0.isEmpty }
+            .joined(separator: " ")
+        let compact = normalized.replacingOccurrences(of: " ", with: "")
+
+        let candidateTerms: [String] = compact == normalized
+            ? [normalized]
+            : [normalized, compact]
+
+        var variants: [SearchVariant] = []
+        var seenKeys = Set<String>()
+
+        func appendVariant(
+            term: String,
+            country: String?,
+            language: String?,
+            attribute: String?
+        ) {
+            let key = [
+                term.lowercased(),
+                country?.lowercased() ?? "",
+                language?.lowercased() ?? "",
+                attribute?.lowercased() ?? ""
+            ].joined(separator: "|")
+            guard seenKeys.insert(key).inserted else { return }
+            variants.append(
+                SearchVariant(
+                    term: term,
+                    country: country,
+                    language: language,
+                    attribute: attribute
+                )
+            )
+        }
+
+        for term in candidateTerms {
+            appendVariant(term: term, country: "KR", language: "ko_kr", attribute: "songTerm")
+            appendVariant(term: term, country: "KR", language: "ko_kr", attribute: nil)
+        }
+
+        if let primaryTerm = candidateTerms.first {
+            appendVariant(term: primaryTerm, country: nil, language: nil, attribute: nil)
+        }
+
+        return variants
+    }
+
+    private func normalizedTrackIdentity(for track: SpotifySimpleTrack) -> String {
+        "\(normalizedIdentityComponent(track.title))|\(normalizedIdentityComponent(track.artist))"
+    }
+
+    private func normalizedIdentityComponent(_ value: String) -> String {
+        value
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .folding(options: [.diacriticInsensitive, .caseInsensitive], locale: .current)
+            .replacingOccurrences(of: "\\s+", with: "", options: .regularExpression)
+    }
+
+    private struct SearchVariant {
+        let term: String
+        let country: String?
+        let language: String?
+        let attribute: String?
+    }
+
     private func mapToSimpleTrack(_ item: ITunesTrackItem) -> SpotifySimpleTrack? {
         let title = (item.trackName ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
         let artist = (item.artistName ?? "").trimmingCharacters(in: .whitespacesAndNewlines)

KillingPart/ViewModels/Add/AddTabViewModel.swift

@@ -8,6 +8,7 @@ final class AddTabViewModel: ObservableObject {
     @Published private(set) var isLoadingMore = false
     @Published var errorMessage: String?
 
+    private let spotifyService: SpotifyServicing
     private let itunesService: ITunesServicing
     private var searchTask: Task<Void, Never>?
     private var loadMoreTask: Task<Void, Never>?
@@ -16,7 +17,11 @@ final class AddTabViewModel: ObservableObject {
     private var nextOffset = 0
     private var hasMoreResults = true
 
-    init(itunesService: ITunesServicing = ITunesService()) {
+    init(
+        spotifyService: SpotifyServicing = SpotifyService(),
+        itunesService: ITunesServicing = ITunesService()
+    ) {
+        self.spotifyService = spotifyService
         self.itunesService = itunesService
     }
 
@@ -143,7 +148,7 @@ final class AddTabViewModel: ObservableObject {
         }
 
         do {
-            let fetchedTracks = try await itunesService.searchTracks(
+            let fetchedTracks = try await fetchTracks(
                 query: query,
                 limit: pageSize,
                 offset: offset
@@ -153,8 +158,8 @@ final class AddTabViewModel: ObservableObject {
             case .initial:
                 tracks = fetchedTracks
             case .pagination:
-                let existingTrackIDs = Set(tracks.map(\.id))
-                let newTracks = fetchedTracks.filter { !existingTrackIDs.contains($0.id) }
+                let existingTrackKeys = Set(tracks.map { normalizedTrackIdentity(for: $0) })
+                let newTracks = fetchedTracks.filter { !existingTrackKeys.contains(normalizedTrackIdentity(for: $0)) }
                 tracks.append(contentsOf: newTracks)
                 if fetchedTracks.isEmpty || newTracks.isEmpty {
                     hasMoreResults = false
@@ -182,12 +187,128 @@ final class AddTabViewModel: ObservableObject {
         hasMoreResults = true
     }
 
+    private func fetchTracks(
+        query: String,
+        limit: Int,
+        offset: Int
+    ) async throws -> [SpotifySimpleTrack] {
+        let safeLimit = max(limit, 1)
+        let safeOffset = max(offset, 0)
+
+        async let spotifyResult = fetchSpotifyTracks(
+            query: query,
+            limit: safeLimit,
+            offset: safeOffset
+        )
+        async let iTunesResult = fetchITunesTracks(
+            query: query,
+            limit: max(safeLimit * 2, safeLimit),
+            offset: safeOffset
+        )
+
+        let spotifyOutcome = await spotifyResult
+        let iTunesOutcome = await iTunesResult
+
+        let mergedTracks = mergeTracks(
+            primary: spotifyOutcome.tracks,
+            secondary: iTunesOutcome.tracks,
+            limit: safeLimit
+        )
+
+        if !mergedTracks.isEmpty {
+            return mergedTracks
+        }
+
+        if spotifyOutcome.didSucceed || iTunesOutcome.didSucceed {
+            return []
+        }
+
+        if let spotifyError = spotifyOutcome.error {
+            throw spotifyError
+        }
+
+        if let iTunesError = iTunesOutcome.error {
+            throw iTunesError
+        }
+
+        return []
+    }
+
+    private func fetchSpotifyTracks(
+        query: String,
+        limit: Int,
+        offset: Int
+    ) async -> (tracks: [SpotifySimpleTrack], error: Error?, didSucceed: Bool) {
+        do {
+            let tracks = try await spotifyService.searchTracks(
+                query: query,
+                limit: limit,
+                offset: offset
+            )
+            return (tracks, nil, true)
+        } catch {
+            return ([], error, false)
+        }
+    }
+
+    private func fetchITunesTracks(
+        query: String,
+        limit: Int,
+        offset: Int
+    ) async -> (tracks: [SpotifySimpleTrack], error: Error?, didSucceed: Bool) {
+        do {
+            let tracks = try await itunesService.searchTracks(
+                query: query,
+                limit: limit,
+                offset: offset
+            )
+            return (tracks, nil, true)
+        } catch {
+            return ([], error, false)
+        }
+    }
+
+    private func mergeTracks(
+        primary: [SpotifySimpleTrack],
+        secondary: [SpotifySimpleTrack],
+        limit: Int
+    ) -> [SpotifySimpleTrack] {
+        var merged: [SpotifySimpleTrack] = []
+        var dedupeKeys = Set<String>()
+
+        for track in primary + secondary {
+            let key = normalizedTrackIdentity(for: track)
+            guard dedupeKeys.insert(key).inserted else { continue }
+            merged.append(track)
+            if merged.count == limit {
+                break
+            }
+        }
+
+        return merged
+    }
+
+    private func normalizedTrackIdentity(for track: SpotifySimpleTrack) -> String {
+        "\(normalizedIdentityComponent(track.title))|\(normalizedIdentityComponent(track.artist))"
+    }
+
+    private func normalizedIdentityComponent(_ value: String) -> String {
+        value
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .folding(options: [.diacriticInsensitive, .caseInsensitive], locale: .current)
+            .replacingOccurrences(of: "\\s+", with: "", options: .regularExpression)
+    }
+
     private enum SearchMode {
         case initial
         case pagination
     }
 
     private func resolveErrorMessage(from error: Error) -> String {
+        if let spotifyError = error as? SpotifyServiceError {
+            return spotifyError.errorDescription ?? "음악 검색에 실패했어요."
+        }
+
         if let itunesError = error as? ITunesServiceError {
             return itunesError.errorDescription ?? "음악 검색에 실패했어요."
         }