[Feat] 네트워크 재시도 에러 View 구현

Projects/DataSource/Sources/NetworkService/NetworkService.swift

@@ -60,7 +60,19 @@ final class NetworkService {
             }
         }
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let data: Data
+        let response: URLResponse
+        do {
+            (data, response) = try await URLSession.shared.data(for: request)
+        } catch let error as URLError {
+            if [.notConnectedToInternet, .timedOut, .networkConnectionLost].contains(error.code) {
+                throw NetworkError.needRetry
+            } else {
+                throw NetworkError.unknown(description: error.localizedDescription)
+            }
+        } catch {
+            throw NetworkError.unknown(description: error.localizedDescription)
+        }
 
         if withPlugins {
             for plugin in plugins {

Projects/DataSource/Sources/Repository/EmotionRepository.swift

@@ -12,28 +12,64 @@ final class EmotionRepository: EmotionRepositoryProtocol {
 
     func fetchEmotions() async throws -> [EmotionEntity] {
         let endpoint = EmotionEndpoint.fetchEmotions
-        guard let response = try await networkService.request(endpoint: endpoint, type: [EmotionResponseDTO].self)
-        else { return [] }
 
-        let emotionEntities = response.compactMap({ $0.toEmotionEntity() })
-        return emotionEntities
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: [EmotionResponseDTO].self)
+            else { return [] }
+
+            let emotionEntities = response.compactMap({ $0.toEmotionEntity() })
+            return emotionEntities
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func loadEmotion(date: String) async throws -> EmotionEntity? {
         let endpoint = EmotionEndpoint.loadEmotion(date: date)
-        guard let response = try await networkService.request(endpoint: endpoint, type: EmotionResponseDTO.self)
-        else { throw NetworkError.unknown(description: "Emotion Reponse를 받아오지 못했습니다.") }
 
-        let emotionEntity = response.toEmotionEntity()
-        return emotionEntity
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: EmotionResponseDTO.self)
+            else { throw NetworkError.unknown(description: "Emotion Reponse를 받아오지 못했습니다.") }
+
+            let emotionEntity = response.toEmotionEntity()
+            return emotionEntity
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func registerEmotion(emotion: String) async throws -> [RecommendedRoutineEntity] {
         let endpoint = EmotionEndpoint.registerEmotion(emotion: emotion)
-        guard let response = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineListResponseDTO.self)
-        else { return [] }
 
-        let recommendedRoutineEntity = response.recommendedRoutines.compactMap({ $0.toRecommendedRoutineEntity() })
-        return recommendedRoutineEntity
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineListResponseDTO.self)
+            else { return [] }
+
+            let recommendedRoutineEntity = response.recommendedRoutines.compactMap({ $0.toRecommendedRoutineEntity() })
+            return recommendedRoutineEntity
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 }

Projects/DataSource/Sources/Repository/FileRepository.swift

@@ -15,11 +15,34 @@ final class FileRepository: FileRepositoryProtocol {
         let dtos = fileNames.map { FilePresignedConditionDTO(prefix: prefix, fileName: $0) }
         let endpoint = FilePresignedEndpoint.fetchPresignedURL(presignedConditions: dtos)
 
-        return try await networkService.request(endpoint: endpoint, type: [String:String].self)
+        do {
+            return try await networkService.request(endpoint: endpoint, type: [String:String].self)
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func uploadFile(url: String, data: Data) async throws {
         let endPoint = S3Endpoint.uploadImage(uploadURL: url, data: data)
-        _ = try await networkService.request(endpoint: endPoint, type: EmptyResponseDTO.self)
+
+        do {
+            _ = try await networkService.request(endpoint: endPoint, type: EmptyResponseDTO.self)
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 }

Projects/DataSource/Sources/Repository/LocationRepository.swift

@@ -44,11 +44,22 @@ final class LocationRepository: NSObject, LocationRepositoryProtocol {
 
         let endpoint = LocationEndpoint.fetchAddress(longitude: longitude, latitude: latitude)
 
-        guard let response = try await networkService.request(endpoint: endpoint, type: KakaoLocationResponseDTO.self)
-        else { return nil }
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: KakaoLocationResponseDTO.self)
+            else { return nil }
 
-        let location = response.toLocationEntity(fallbackLongitude: coordinate.longitude, fallbackLatitude: coordinate.latitude)
-        return location
+            let location = response.toLocationEntity(fallbackLongitude: coordinate.longitude, fallbackLatitude: coordinate.latitude)
+            return location
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     private func requestAuthorizationIfNeeded() async -> CLAuthorizationStatus {

Projects/DataSource/Sources/Repository/OnboardingRepository.swift

@@ -13,11 +13,21 @@ final class OnboardingRepository: OnboardingRepositoryProtocol {
 
     func loadOnboardingResult() async throws -> OnboardingEntity {
         let endpoint = OnboardingEndpoint.loadOnboardingResult
-        guard let response = try await networkService.request(endpoint: endpoint, type: OnboardingResponseDTO.self)
-        else { throw UserError.onboardingLoadFailed }
 
-        let onboardingEntity = response.toOnboardingEntity()
-        return onboardingEntity
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: OnboardingResponseDTO.self)
+            else { throw UserError.onboardingLoadFailed }
+
+            let onboardingEntity = response.toOnboardingEntity()
+            return onboardingEntity
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        }
     }
 
     func registerOnboarding(onboardingEntity: OnboardingEntity) async throws -> [RecommendedRoutineEntity] {
@@ -27,15 +37,39 @@ final class OnboardingRepository: OnboardingRepositoryProtocol {
             realOutingFrequency: onboardingEntity.frequency,
             targetOutingFrequency: onboardingEntity.outdoor)
         let endpoint = OnboardingEndpoint.registerOnboarding(onboarding: onboardingDTO)
-        guard let response = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineListResponseDTO.self)
-        else { return [] }
-
-        let recommendedRoutineEntity = response.recommendedRoutines.compactMap({ $0.toRecommendedRoutineEntity() })
-        return recommendedRoutineEntity
+
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineListResponseDTO.self)
+            else { return [] }
+
+            let recommendedRoutineEntity = response.recommendedRoutines.compactMap({ $0.toRecommendedRoutineEntity() })
+            return recommendedRoutineEntity
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func registerRecommendedRoutines(selectedRoutines: [Int]) async throws {
         let endpoint = OnboardingEndpoint.registerRecommendedRoutine(selectedRoutines: selectedRoutines)
-        _ = try await networkService.request(endpoint: endpoint, type: EmptyResponseDTO.self)
+
+        do {
+            _ = try await networkService.request(endpoint: endpoint, type: EmptyResponseDTO.self)
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 }

Projects/DataSource/Sources/Repository/RecommendedRoutineRepository.swift

@@ -13,23 +13,46 @@ final class RecommendedRoutineRepository: RecommendedRoutineRepositoryProtocol {
     func fetchRecommendedRoutine(id: Int) async throws -> RecommendedRoutineEntity? {
         let endpoint = RecommendedRoutineEndpoint.fetchRecommendedRoutine(id: id)
 
-        guard let recommendedRoutineDTO = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineDTO.self)
-        else { return nil }
-
-        return recommendedRoutineDTO.toRecommendedRoutineEntity()
+        do {
+            guard let recommendedRoutineDTO = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineDTO.self)
+            else { return nil }
+
+            return recommendedRoutineDTO.toRecommendedRoutineEntity()
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func fetchRecommendedRoutines() async throws -> [RecommendedRoutineEntity] {
         let endpoint = RecommendedRoutineEndpoint.fetchRecommendedRoutines
-        guard let response = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineDictionaryResponseDTO.self)
-        else { return [] }
 
-        var entities: [RecommendedRoutineEntity] = []
-        for (category, recommendedRoutines) in response.recommendedRoutines {
-            let recommendedRoutineEntity = recommendedRoutines.compactMap({ $0.toRecommendedRoutineEntity(category: category) })
-            entities.append(contentsOf: recommendedRoutineEntity)
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: RecommendedRoutineDictionaryResponseDTO.self)
+            else { return [] }
+
+            var entities: [RecommendedRoutineEntity] = []
+            for (category, recommendedRoutines) in response.recommendedRoutines {
+                let recommendedRoutineEntity = recommendedRoutines.compactMap({ $0.toRecommendedRoutineEntity(category: category) })
+                entities.append(contentsOf: recommendedRoutineEntity)
+            }
+
+            return entities
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
         }
-
-        return entities
     }
 }

Projects/DataSource/Sources/Repository/ReportRepository.swift

@@ -33,30 +33,66 @@ final class ReportRepository: ReportRepositoryProtocol {
         )
 
         let endpoint = ReportEndpoint.register(report: reportDTO)
-        guard let id = try await networkService.request(endpoint: endpoint, type: Int.self) else { return nil }
 
-        return id
+        do {
+            guard let id = try await networkService.request(endpoint: endpoint, type: Int.self) else { return nil }
+
+            return id
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func fetchReports() async throws -> [ReportEntity] {
         let endpoint = ReportEndpoint.fetchReports
-        guard let response = try await networkService.request(endpoint: endpoint, type: ReportDictonaryDTO.self)
-        else { return [] }
 
-        var reportEntities: [ReportEntity] = []
-        for (date, reports) in response.reportInfos {
-            let reportHistories = reports.compactMap({ try? $0.toReportEntity(date: date) })
-            reportEntities += reportHistories
-        }
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: ReportDictonaryDTO.self)
+            else { return [] }
+
+            var reportEntities: [ReportEntity] = []
+            for (date, reports) in response.reportInfos {
+                let reportHistories = reports.compactMap({ try? $0.toReportEntity(date: date) })
+                reportEntities += reportHistories
+            }
 
-        return reportEntities
+            return reportEntities
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 
     func fetchReportDetail(reportId: Int) async throws -> ReportEntity? {
         let endpoint = ReportEndpoint.fetchReportDetail(reportId: reportId)
-        guard let response = try await networkService.request(endpoint: endpoint, type: ReportDTO.self)
-        else { return nil }
 
-        return try response.toReportEntity()
+        do {
+            guard let response = try await networkService.request(endpoint: endpoint, type: ReportDTO.self)
+            else { return nil }
+
+            return try response.toReportEntity()
+        } catch let error as NetworkError {
+            switch error {
+            case .needRetry, .invalidURL, .emptyData:
+                throw DomainError.requireRetry
+            default:
+                throw DomainError.business(error.description)
+            }
+        } catch {
+            throw DomainError.unknown
+        }
     }
 }