발전하는 iOS와 Clean Swift Architecture

public struct UploadReceiptSwiftUIView: View {
    private let controller: UploadReceiptControllerable
    @ObservedObject private var store: UploadReceiptStore

    // ..

    public var body: some View {
        // ..
        .onTapGesture {
            self.controller.execute(.imageAttachTapped)
        }
    }
}

public final class UploadReceiptUIKitView: UIViewController {
    private let controller: UploadReceiptControllerable
    private var store: UploadReceiptStore

    // ..

    private func bind() {
        
        self.store.$state
            .map { $0.attachedImages }
            .sink { [weak self] attachedImages in
                self?.updateImageScrollView(with: attachedImages)
            }
            .store(in: &self.cancellables)
    }
}

public enum UploadReceiptAction {
    // ..
    case cameraCanceled
    case imagePicked
}

final class UploadReceiptController: UploadReceiptControllerable {
    
    private let interactor: UploadReceiptInteractable
    private weak var store: UploadReceiptMutatable?
    
    // ..
}

extension UploadReceiptController {
    
    private func execute(_ action: UploadReceiptAction) async {
        switch action {
        // ..
        case .cameraCanceled:
            await self.store?.execute(.dismissCamera)

        case .imagePicked(let image):
            await self.interactor.execute(.attachImage(request: UploadReceipt.AttachImage.Request(imageUIData: image)))
            await self.store?.execute(.dismissImagePicker)
        }
    }
}

public enum UploadReceipt {
    // ..
    
    // MARK: - UseCases
    
    enum AttachImage {
        
        struct Request {
            let imageUIData: ImageUIDataModel
        }
        
        struct Response {
            let attachedImages: [ImageModel]
            let error: Error?
            
            enum Error {
                case exceedImageCount
                case failDataMapping
            }
        }
    }
}

enum UploadReceiptUseCase {
    case attachImage(request: UploadReceipt.AttachImage.Request)
    case uploadImage(request: UploadReceipt.UploadImage.Request)
    case saveImage(request: UploadReceipt.SaveImage.Request)
    case showCamera(request: UploadReceipt.ShowCamera.Request)
    case showGallery(request: UploadReceipt.ShowGallery.Request)
}

final class UploadReceiptInteractor: UploadReceiptInteractable {
    
    private let store: UploadReceiptMutatable & HasUploadReceiptDomainState
    private let worker: UploadReceiptWorkable
    
    // ..
}

extension UploadReceiptInteractor {
    
    func execute(_ useCase: UploadReceiptUseCase) async {
        switch useCase {
        // ..
        case .attachImage(let request):
            let response: UploadReceipt.AttachImage.Response
            let storedAttachedImages = await self.store.domainState.attachedImages
            
            if storedAttachedImages.count >= 5 {
                response = UploadReceipt.AttachImage.Response(
                    attachedImages: storedAttachedImages,
                    error: .exceedImageCount
                )
            }
            else if let imageData = self.worker.mapToData(from: request.imageUIData) {
                response =  UploadReceipt.AttachImage.Response(
                    attachedImages: storedAttachedImages + [UploadReceipt.ImageModel(data: imageData, uiData: request.image)],
                    error: nil
                )
            }
            else {
                response = UploadReceipt.AttachImage.Response(
                    attachedImages: storedAttachedImages,
                    error: .failDataMapping
                )
            }
            
            await self.store.execute(.mutateAttachImage(response: response))

        case .uploadImage(_):
            let response: UploadReceipt.UploadImage.Response
            let storedAttachedImages = await self.store.domainState.attachedImages
            
            if storedAttachedImages.isEmpty {
                response =  UploadReceipt.UploadImage.Response(
                    uploadUrlObjectKeys: [],
                    error: .emptyAttachedImage
                )
            }
            else {
                do {
                    let uploadUrls = try await self.worker.fetchImageUploadUrls(names: storedAttachedImages.map({ $0.name }))
                    try await self.worker.requestImagesUpload(attatchedImages: storedAttachedImages, imageUploadUrls: uploadUrls)
                    
                    response = UploadReceipt.UploadImage.Response(
                        uploadUrlObjectKeys: uploadUrls.map({ $0.objectKey }),
                        error: nil
                    )
                }
                catch {
                    response = UploadReceipt.UploadImage.Response(
                        uploadUrlObjectKeys: [],
                        error: .default(error)
                    )
                }
            }
            
            await self.store.execute(.mutateUploadImage(response: response))
        }
    }
}

enum UploadReceiptMutation {
    case mutateAttachImage(response: UploadReceipt.AttachImage.Response)
    // ..
    case dismissCamera
    case dismissImagePicker
}

@MainActor public struct UploadReceiptState {
    // ..
    struct DomainState {
        // ..
    }
}

@MainActor final class UploadReceiptStore: UploadReceiptMutatable, HasUploadReceiptDomainState, ObservableObject {
    
    let worker: UploadReceiptWorkable
    @Published private(set) var state: UploadReceiptState
    // ..
}

extension UploadReceiptStore {
    
    private func execute(state: UploadReceiptState, mutation: UploadReceiptMutation) -> UploadReceiptState {
        var state = state
        
        switch mutation {
        case .mutateAttachImage(let response):
            if let error = response.error {
                switch error {
                case .exceedImageCount:
                    self.worker.showToast(message: "최대 5장까지 첨부할 수 있습니다")
                    
                case .failDataMapping:
                    self.worker.showToast(message: "사진 처리 과정에서 오류가 발생하였습니다")
                }
            }
            else {
                state.domainState.attachedImages = response.attachedImages
                state.attachedImages = response.attachedImages.map { $0.uiData }
            }
        // .. 
        case .dismissCamera:
            state.showingCamera = false
            
        case .dismissImagePicker:
            state.showingImagePicker = false
        }

        return state
    }
}

protocol UploadReceiptWorkable: AnyObject {
    // ..
    
    @MainActor func showToast(message: String)
    
    func requestImagesUpload(attatchedImages: [UploadReceipt.ImageModel], imageUploadUrls: [UploadReceipt.ImageUploadUrl]) async throws
    func requestCameraPermission() async -> Bool
    func requestGalleryPermission() async -> Bool
}

final class UploadReceiptWorker: UploadReceiptWorkable {
    
    private let imageUploadNetworkService: ImageUploadNetworkServiceProtocol
    
    // ..
}

extension UploadReceiptWorker {
    
    @MainActor func showToast(message: String) {
        Toast(text: message).show()
    }
    
    func requestImagesUpload(attatchedImages: [UploadReceipt.ImageModel], imageUploadUrls: [UploadReceipt.ImageUploadUrl]) async throws {
        return try await withThrowingTaskGroup(of: Void.self) { group in
            for (imageUploadUrl, attachedImage) in zip(imageUploadUrls, attatchedImages) {
                group.addTask {
                    try await self.imageUploadNetworkService.putImageData(to: imageUploadUrl.uploadUrl, imageData: attachedImage.data)
                }
            }
            try await group.waitForAll()
        }
    }
    
    func requestCameraPermission() async -> Bool {
        return await withCheckedContinuation { continuation in
            AVCaptureDevice.requestAccess(for: .video) { granted in
                continuation.resume(returning: granted)
            }
        }
    }
    
    func requestGalleryPermission() async -> Bool {
        return await withCheckedContinuation { continuation in
            if #available(iOS 14, *) {
                PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
                    continuation.resume(returning: status == .authorized)
                }
            } else {
                PHPhotoLibrary.requestAuthorization { status in
                    continuation.resume(returning: status == .authorized)
                }
            }
        }
    }
}

public enum UploadReceipt {
    
    // MARK: - Entities
    
    public struct ImageModel {
        let name: String = "\(Date().timeIntervalSince1970)_\(UUID())"
        let data: Data
        let uiData: ImageUIDataModel
    }
    
    // MARK: - ViewModels
    
    public typealias ImageUIDataModel = UIImage
    
    // MARK: - UseCases
    
    enum AttachImage {
        
        struct Request {
            let imageUIData: ImageUIDataModel
        }
        
        struct Response {
            let attachedImages: [ImageModel]
            let error: Error?
            
            enum Error {
                case exceedImageCount
                case failDataMapping
            }
        }
    }
}

// Controller
public protocol UploadReceiptControllerable: AnyObject {
    @discardableResult func execute(_ action: UploadReceiptAction) -> Task<Void, Never>
}

// Interactor
protocol UploadReceiptInteractable {
    func execute(_ useCase: UploadReceiptUseCase) async
}

// Store
protocol UploadReceiptMutatable: AnyObject {
    @MainActor func execute(_ mutation: UploadReceiptMutation)
}

final class UploadReceiptSceneTests: XCTestCase {
    
    var controller: UploadReceiptController!
    @MainActor var state: UploadReceiptState { self.store.state }
    
    // ..

    func test_사진선택완료_첨부된사진5개이상__토스트메세지표출됨() async {
        // Given
        await MainActor.run {
            self.mockWorker.mapToDataResult = Data()
            
            var state = UploadReceiptState()
            state.domainState.attachedImages = [
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage()),
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage()),
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage()),
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage())
            ]
            self.configure(initialState: state)
        }
        
        // When
        await self.controller.execute(.imagePicked(image: UploadReceipt.ImageUIDataModel())).value
        
        // Then
        let lastShowToastMessage = self.mockWorker.lastShowToastMessage
        
        XCTAssertEqual(lastShowToastMessage, "최대 5장까지 첨부할 수 있습니다")
    }

    func test_사진선택완료_첨부된사진5개미만__첨부된이미지목록에추가됨() async {
        // Given
        await MainActor.run {
            self.mockWorker.mapToDataResult = Data()
            
            var state = UploadReceiptState()
            state.domainState.attachedImages = [
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage()),
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage()),
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage()),
                UploadReceipt.ImageModel(data: Data(), uiData: UIImage())
            ]
            self.configure(initialState: state)
        }
        
        // When
        await self.controller.execute(.imagePicked(image: UploadReceipt.ImageUIDataModel())).value
        
        // Then
        let domainAttachedImages = await self.state.domainState.attachedImages
        let attachedImages = await self.state.attachedImages
        
        XCTAssertEqual(domainAttachedImages.count, 5)
        XCTAssertEqual(attachedImages.count, 5)
    }
}

extension UploadReceiptSceneTests {
    
    class MockWorker: UploadReceiptWorkable {
        // ..
    }
}

// 전달할 상태 값 저장
extension UploadReceiptStore {
    
    private func execute(state: UploadReceiptState, mutation: UploadReceiptMutation) -> UploadReceiptState {
        var state = state
        
        switch mutation {
        case .mutateUploadImage(let response):
            state.receiptImageUploadUrlObjectKeys = response.uploadUrlObjectKeys // Data Passing
            state.isAddRequestsViewActive = true // Active AddRequests View
        // ..
        }

        return state
    }
}

// 상위 뷰
public struct UploadReceiptSwiftUIView: View {

        public var body: some View {
        NavigationView {
            // ..
                NavigationLink(
                    isActive: Binding(
                        get: {
                            return self.store.state.isAddRequestsViewActive
                        },
                        // ..
                    ),
                    destination: {
                        AddRequestsSwiftUIView(
                            initialState: AddRequestsState(
                                receiptImageUploadUrlObjectKeys: self.store.state.receiptImageUploadUrlObjectKeys
                            ),
                            // ..
                        )
                    }
                )
        // ..
}

// 하위 뷰
public struct AddRequestsSwiftUIView: View {

    public init(
        initialState: AddRequestsState,
        // ..
    ) {
        // ..
    }
}

// 상위 화면의 Worker
protocol UploadReceiptWorkable: AnyObject {
    var addRequestsController: AddRequestsControllerable? { get set }
}

// 상위 화면에서 하위 화면에 의해 흐름을 위임 받는 로직
extension UploadReceiptController: AddRequestsDelegate {
    
    @MainActor func quotationRequestSuccessed(successMessage: String) {
        self.store?.execute(.setIsActiveAddRequestsView(isActive: false))
        self.store?.execute(.showMessage(message: successMessage))
        self.store?.execute(.clearAttachedImages)
    }
}

// 상위 화면에서 하위 화면에게 흐름을 위임 시키는 로직
extension UploadReceiptStore {
    
    private func execute(state: UploadReceiptState, mutation: UploadReceiptMutation) -> UploadReceiptState {
        var state = state
        
        switch mutation {
        case .mutateSomthing(_):
            self.worker.addRequestsController?.execute(.something)
        // ..
        }
        
        return state
    }
}

// 하위 화면의 Delegate
public protocol AddRequestsDelegate: AnyObject {
    @MainActor func quotationRequestSuccessed(successMessage: String)
}

// 하위 화면의 Worker
protocol AddRequestsWorkable: AnyObject {
    var delegate: AddRequestsDelegate? { get set }
}

// 하위 화면에서 상위 화면에게 흐름을 위임 시키는 로직
extension AddRequestsStore {
    
    func execute(state: AddRequestsState, mutation: AddRequestsMutation) -> AddRequestsState {
        var state = state
        
        switch mutation {
        case .mutateRequestQuotation(let response):
            self.worker.delegate?.quotationRequestSuccessed(successMessage: "견적 요청을 성공하였습니다 :)")
        // ..
        }
        
        return state
    }
}

// 하위 뷰
public struct AddRequestsSwiftUIView: View {
    
    public init(
        initialState: AddRequestsState,
        controller: inout AddRequestsControllerable?,
        delegate: AddRequestsDelegate
    ) {
        let worker = AddRequestsWorker(delegate: delegate, quotationNetworkService: quotationNetworkService)
        let _controller = AddRequestsController(interactor: interactor, store: store)
        controller = _controller
        // ..
    }
}