j_aion.log

[Conference] Swift Concurrency Under the Hood

Sat, 31 Dec 2022 17:15:27 GMT

Swift Concurrency Under the Hood - iOS Conf SG 2022

Swift Concurrency Under the Hood

Concurrency

스레드
GCD
모던 스위프트 컨커런시

Async Await

비동기 컨텍스트에서 실행되는 함수를 컴플리션을 통해 실행하지 않더라도 실행 가능하도록 지원
Task 내부 또는 async를 따르는 함수에서 do catch 등을 통해 await로 비동기적으로 종료되는 태스크의 실행을 캐치 가능

import SwiftUI

struct MyStorage {
    static func fetchID() async {
        print("Async Work")
    }

    static func fetchID() {
        print("Sync Work")
    }
}

struct ConcurrencyView: View {
    var body: some View {
        Text("Hello, World!")
            .onAppear(perform: MyStorage.fetchID)
            .task {
                await MyStorage.fetchID()
            }
    }
}

태스크 모디파이어를 통해 비동기 함수 실행
```
Sync Work
Async Work
```

비동기/동기 함수가 실행되는 구문 확인 가능

struct ConcurrencyView: View {
  var body: some View {
      Text("Hello, World!")
          .onAppear(perform: MyStorage.fetchID)
          .task {
                 MyStorage.fetchID()
          }
  }
}

태스크 모디파이어 내부에서 await를 쓰지 않고 fetchID()를 호출했을 때 컴파일러는 동일한 이름의 동기 함수를 실행
```
Sync Work
Sync Work
```
동일한 동기 함수가 실행되는 것을 확인 가능 → await 키워드 필수

Task Groups

인풋이 동적으로 들어오는 비동기 리퀘스트를 병렬적으로 실행한 뒤 결과를 종합해서 리턴/사용해야 할 때 사용 가능한 방식

func loginAndAskAndConnet() {
  try await withThrowingTaskGroup(of: LoginTaskResult.self, body: { group in
      group.addTask(operation: fetchLocation)
      group.addTask(operation: askForUserPermission)
      group.addTask(priority: .high) {
          return .client(try await APIClient.connect())
      }

      var client: APIClient!
      for try await result in group {
          if case LoginTaskResult.client(let api) = result {
              client = api
              break
          }
      }
      let tracer = client.traceEvent

      group.addTask(operation: client.logUserIn)
      group.addTask {
          try await tracer(.login)
      }
      try await group.waitForAll()
      _ = try await tracer(.completedLoginSequence)
  })
}

* 로그인 태스크에서 발생한 가능한 타입이 `of`를 통해 주어진 태스크 그룹
* 세 가지 태스크가 그룹에 추가 → 위치를 가져오면서 유저의 허락을 구하고 API 클라이언트와 연결하는 작업
* `for try await`를 통해 `AsyncSequence`를 다루면서 태스크 그룹이 리턴하는 클라이언트 api 데이터를 가져온 뒤 클라이언트의 로그인 태스크 및 이벤트 추적을 동시적으로 진행
* `group.waitForAll()`을 통해 그룹 내에 추가된 모든 태스크가 종료될 때까지 보장
* 위 컨커런트한 태스크 그룹 → 해당 태스크 종료 후에야 특정 태스크 실행 가능한 흐름일 때 도중 특정한 태스크에서 에러를 스로우한다면 → 자동으로 그룹 내 에러가 발생한 태스크 이외의 (종료되지 않은) 태스크는 자동으로 캔슬
* 태스크 그룹에 대한 자동 스레드 할당 방법: 컨커런트 디스패치 큐인 `user-initiated-qos.cooperative` 스레드 풀에서 멀티 스레드를 통해 실행
* 각 스레드 풀에서 실행되는 스레드 개수는 디바이스의 코어 개수에 따라 상이(아이폰, 맥 등)

## Actors
* 레이스 문제를 해결하는 가장 간단한 방법 중 한 가지
```swift
actor MyActor {
    private var counter = 0

    public func increment() {
        counter += 1
    }
}

해당 increment()를 실행하는 호출 순서가 액터가 주관하는 큐에서 실행

struct MyModel {
  @MainActor func updateItems() {}
  @MainActor func clearAllItems() {}
}

struct Logger { @MainActor var logs: [String] }

@MainActor struct UIHelpers { // members }

* 일반적인 액터 클래스 이외에도 해당 함수, 변수 등이 `@MainActor`와 같은 형식으로 선언된다면 해당 함수 실행이 곧 `isolated`된다는 뜻
* 구조체, 클래스 자체를 `@MainActor`와 같은 형식으로 선언했다면 내부의 모든 데이터, 함수 등이 `isolated`되는 게 디폴트이기 때문에 그렇지 않은 대상에 ``nonisolted`로 별도로 선언해 주어야 함

## Actors Protocol
* 프로토콜을 통해 액터를 따를 때 인스턴스 프로퍼티로 `unownedExecutor`가 존재
* 해당 익스큐터는 `unowned` 참조로서 해당 액터를 실행하는 익스큐터를 반환하는 프로퍼티 변수(익스큐터란 해당 액터가 주관하는 동작을 순차적으로 실행하도록 보장하는 큐)
* 해당 익스큐터를 커스텀한다면 보다 많은 일을 할 수 있을 거라 기대

## Distributed Actor

```swift
distributed actor Database {
    func allUsers() -> [User] { ... }
}

let database = try Database.resolve(id: IP("111.222.333"), using: HTTPSTransport())
let users = try await database.allUsers()

distributed를 사용한 액터 클래스

해당 강의가 나온 시점에 distributed 키워드는 아직 도입되지 않은 상황이었는데, 해당 방법을 통해 액터를 사용할 때의 이점을 설명하고 있다
앱 내의 여러 프로세스가 존재할 때 특정 프로세스를 외부 데이터센터에서 실행할 수 있는 방법을 모색하고 있는 듯

[UIKit] Runloop.Main vs DispatchQueue.Main

Sat, 31 Dec 2022 16:14:14 GMT

Common Mistake while using @Published | RunLoop.Main vs DispatchQueue.Main | Combine

Runloop.Main vs DispatchQueue.Main

@Published

컴바인을 사용해 간단한 테이블 뷰를 그리기

특정 버튼을 통해 테이블 뷰의 데이터 소스를 갱신

class TableViewModel {
  @Published var data = [String]() {
      willSet {
          print("Willset executed")
      }
      didSet {
          print("Didset executed")
      }
  }

  init() {
  }

  func fetchData() {
      var data = [String]()
      for _ in 1...100 {
          let rand = Int.random(in: 1...100)
          data.append(rand.description)
      }
      self.data = data
  }
}

* `@Published`을 따르는 데이터 소스는 해당 값이 업데이트될 때를 감지
```swift
class TableViewController: UIViewController {
    private lazy var refreshButton: UIButton = {
        let button = UIButton()
        var config = UIButton.Configuration.filled()
        config.baseBackgroundColor = .systemGreen
        config.baseForegroundColor = .white
        config.title = "Refresh"
        button.configuration = config
        button.addTarget(self, action: #selector(didTapRefresh), for: .touchUpInside)
        return button
    }()
    private lazy var tableView: UITableView = {
        let tableView = UITableView()
        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "tableViewCell")
        tableView.dataSource = self
        tableView.delegate = self
        return tableView
    }()
    private var cancelables = Set()
    private let viewModel = TableViewModel()

    override func viewDidLoad() {
        super.viewDidLoad()
        setUI()
        bind()
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        refreshButton.frame = CGRect(x: (view.frame.size.width - 100) / 2, y: view.safeAreaInsets.top, width: 100, height: 50)
        tableView.frame = CGRect(x: 0, y: refreshButton.frame.origin.y + 50 + 10, width: view.frame.size.width, height: view.frame.size.height)
    }

    private func setUI() {
        view.backgroundColor = .systemBackground
        view.addSubview(tableView)
        view.addSubview(refreshButton)
    }

    @objc private func didTapRefresh() {
        viewModel.fetchData()
    }

    private func bind() {
        viewModel
            .$data
            .sink { [weak self] _ in
                print("TableView reload!")
                self?.tableView.reloadData()
            }
            .store(in: &cancelables)
    }
}

뷰 모델이 가지고 있는 데이터 퍼블리셔가 관찰될 때마다 테이블 뷰를 갱신

extension TableViewController: UITableViewDelegate, UITableViewDataSource {
  func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
      viewModel.data.count
  }

  func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
      let cell = tableView.dequeueReusableCell(withIdentifier: "tableViewCell", for: indexPath)
      var content = cell.defaultContentConfiguration()
      let model = viewModel.data[indexPath.row]
      content.text = model
      content.textProperties.alignment = .center
      cell.contentConfiguration = content
      return cell
  }
}

* 현 시점의 뷰 모델의 데이터 소스가 가지고 있는 값을 통해 테이블 뷰 UI 구성

![](https://velog.velcdn.com/images/j_aion/post/cc2c76d7-ba4d-418b-9eea-b17b4bbd52fd/image.gif)
* 하지만 리프레시 버튼을 두 번 클릭해서야 이전의 값을 확인 가능

```swift
TableView reload!
Willset executed
TableView reload!
Didset executed
Willset executed
TableView reload!
Didset executed

퍼블리셔의 Willset이 호출된 뒤 퍼블리셔 변경을 감지하여 뷰 컨트롤러에서 구독한 tableView.reloadData()가 호출되는 데, 이 시점에서는 실제 데이터가 들어가기 전이므로 이전 값이 계속 유지됨. 즉 업데이트될 것은 체크했으나 업데이트되기 전의 값을 통해 UI를 그리기 때문에 두 번 클릭해야 하는 불상사 발생
```
private func bind() {
      viewModel
          .$data
          .receive(on: DispatchQueue.main)
          .sink { [weak self] _ in
              print("TableView reload!")
              self?.tableView.reloadData()
          }
          .store(in: &cancelables)
  }
```
위 상황을 퍼블리셔를 구독하는 receive 메소드를 통해 해결 가능
DispatchQueue.main 또는 Runloop.main을 통해 해당 데이터 퍼블리셔의 변경 사항을 구독할 경우 올바른 행동을 기대 가능

TableView reload!
Willset executed
Didset executed
TableView reload!
Willset executed
Didset executed
TableView reload!

리프레시 버튼을 누른 직후 퍼블리셔가 변경, didSet이 호출된 이후에야 제대로 업데이트된 값을 통해 테이블 뷰 UI를 그리기 때문에 올바른 타이밍에서 호출

Runloop.Main vs DispatchQueue.Main

기본적으로 같은 개념
런루프는 특정 태스크 스케줄링에 사용하는 이벤트 처리 루프
각 스레드(커스텀 스레드 또는 시스템에 의한 디폴트 스레드 모두)는 각자의 런루프를 가지는 데, 메인 스레드와 연관된 모든 런루프가 곧 런루프 메인
디스패치 큐는 메인 스레드와 연관 된 디스패치 큐로 메인 스레드와 연관된 시리얼 큐가 곧 디스패치 큐 메인 스레드로 UIKit의 모든 뷰 드로우 사이클이 해당 스레드와 연관
런루프는 perform selector를 사용하는 반면 디스패치 큐는 일반적인 GCD 메소드를 사용하면서 실행
런루프는 디폴트 모드에서 사용될 때에만 콜백 가능 → 유저 인터렉션과 함께 백그라운드 태스크를 작업해야 할 경우 사용 불가능(유저가가 테이블 뷰를 스크롤할 때 해당 셀에서 내부적으로 이미지를 다운로드받아야 하는 백그라운드 태스크를 실행할 때 런루프 메인을 사용할 때에는 해당 다운로드 작업이 유저 인터렉션이 끝날 때까지 실행되지 않음) → 런루프를 일종의 스케줄러로 사용하기 때문에 유저 인터렉션을 다루는 중이기 때문

[UIKit] Opaque Type vs Protocol & Associated Type & Generics

Sat, 31 Dec 2022 15:35:21 GMT

https://www.youtube.com/watch?v=SPhATsEQR74

Opaque Type vs Protocol & Associated Type & Generics

Generics

어떤 타입이더라도 적용 가능한 유연성을 보장하는 방법

func swapTwoValues(_ a: inout T, _ b: inout T) {
        let tempA = a
        a = b
        b = tempA
    }

들어오는 데이터의 타입을 모르더라도 받아들일 수 있음
특정 프로토콜을 따르는 데이터 타입만을 받아들일 수도 있음(Decodable 등을 따르는 데이터 타입만을 파라미터로 받아들여 디코딩한 결과를 리턴하는 게 대표적인 예시)

    class someClass { ... }

    protocol someProtocol { ... }  

    func someFunction(someT: T, someU: U) {
        // handle T and U
    }

스위프트가 제공하는 거의 모든 유용한 공통 오퍼레이터가 제네릭을 통해 구현
```
public init(_ base: H) where H: Hashable
```
위와 같이 Hashable 프로토콜을 따르는 타입을 통해 이니셜라이즈한다는 뜻

Associated Types

프로토콜을 보다 유연하게 사용하고자 할 때 사용 가능

protocol someProtocol {
  associatedtype SomePlaceholder

  func someFunctionUsing(type: SomePlaceholder)
  func someOtherFunctionReturning() -> SomePlaceholder
}

특정 프로토콜 내부에서 associatedtype을 통해 연관 타입을 선언한다면, 해당 프로토콜을 따르는 구조체/클래스에서 해당 타입을 명확하게 지정 가능

현 시점에서는 불분명한 타입에 지나지 않음

struct someStruct: someProtocol {
  typealias SomePlaceholder = Int

  func someOtherFunctionReturning() -> Int {
      // return SomePlaceholder as Int
  }

  func someFunctionUsing(type: Int) { }
}

typealias를 통해 해당 프로토콜이 지정한 associatedtype을 구체적으로 지정

해당 타입을 리턴/파라미터로 사용하는 함수에 현 시점의 구체적인 타입을 그대로 적용 가능

protocol stackable {
  associatedtype stackType
  var stack: [stackType] { get set }
  func pop() -> stackType
  func push(_ item: stackType)
}

struct stringStack: stackable { var stack: [String]

func pop() -> String {
    // return pop
}
func push(_ item: String) {
    // handle push
}
typealias stackType = String

}

* 연관 타입을 해당 프로토콜을 따르는 구체적인 구조체/클래스에서 `typealisas`를 통해 직접 설정 가능하다는 게 핵심
```swift
protocol Constainer {
    associatedtype Item: Equatable
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

컨테이너 프로토콜은 Equatable을 따르는 타입을 연관 타입으로 받아, mutating, subscript 등 특정 함수를 내재하는 프로토콜

Opaque + associatedtype

프로토콜이 사용한 연관타입은 오파크와 함께 사용할 시 큰 시너지
```
enum CardType {
  case gold
  case platinum
}
```

protocol CardNumberProtocol { }

extension String: CardNumberProtocol { }

* 특정한 프로토콜이 존재한다고 가정
```swift
protocol Card {
    associatedtype CardNumber: CardNumberProtocol
    var type: CardType { get set }
    var limit: Int { get set }
    var number: CardNumber { get set }
    func validateCardNumber(number: CardNumber)
}

카드 프로토콜의 연관 타입으로 선언된 CardNumber는 위의 CardNumberProtocol을 준수하는 타입임

타입, 리미트, 넘버 등 프로토콜 내 변수 및 validateCardNumber와 같은 연관 타입을 인자로 쓰는 함수 역시 존재

struct VisaCard: Card {
  typealias CardNumber = String
  var type: CardType = .gold
  var limit: Int = 100_000
  var number: String = "1111 2222 3333 4444"
  func validateCardNumber(number: String) {

  }
}

struct MasterCard: Card { typealias CardNumber = String var type: CardType = .platinum var limit: Int = 500_000 var number: String = "1111 2222 3333 4444" func validateCardNumber(number: String) {

}

* 위의 프로토콜을 따르는 구체적인 구조체
* 연관타입이 각 구조체 내부에서 `typealias`로 선언되어 구체화되어 있음
```swift
func getLoadEligibility() -> Bool {
    getUserCard().limit >= getLoanEligibilityCard().limit
}

func getUserCard() -> some Card {
    MasterCard()
}

func getLoanEligibilityCard() -> some Card {
    VisaCard()
}

함수의 리턴 타입으로 카드 프로토콜 자체를 리턴하려면 컴파일러가 연관타입으로 감춰놓은 실제 타입을 알지 못하기 때문에 컴파일러 에러가 발생
some이라는 오파크 타입 키워드를 통해 해당 타입을 '감싸'줄 때 비로소 리턴할 수 있는데, 실제로 제네릭의 완전히 반대 방향으로 작동
실제 리턴하는 구체적인 실제 타입을 Card로는 알아차리지 못하기 때문에(연관 타입의 실제 표현은 각 구조체 내부에서 하도록 설정되었음), some 키워드를 통해 어떤 타입인지는 모르겠으나 해당 프로토콜을 따르는 구조체라서 인지 가능
SwiftUI 프레임워크의 모든 UI를 그리는 구조체가 some View를 따르는 연산 프로퍼티인데, 이 또한 같은 맥락

[Conference] A crash course of async await

Sat, 31 Dec 2022 13:53:50 GMT

A crash course of async await (Swift Concurrency) - Shai Mishali - Swift Heroes 2022

A crash course of async await

Concurrency

시리얼 큐에 할당도힌 작업보다 더 적은 시간을 소모한 채 동일한 결과물을 가져올 수 있다는 장점 → 이슈는 타이밍

History

GCD: 디스패치 그룹, 세마포어, 워크 아이템 등을 통해 특정 비동기 작업의 실행 순서를 지정
completion handler: 이스케이핑 클로저를 통해 비동기적으로 갱신되는 데이터를 할당하는 구조, 하지만 클로저의 개수가 많아지고 예외 케이스 등 처리가 복잡해질 때 코드 복잡성이 많아지는 문제점 발생
Combine

Sync vs Async

동기: (1). 코드 가독성이 좋고 순서대로 실행됨을 보장. 예측 가능. 간단한 에러 핸들링 (2). 시리얼적이고, 블로킹이 발생. 싱글 스레드
비동기: (1). 컨커런시를 구현 가능. 멀티 스레드 환경에 적합. 리소스 최적화에 있어 뛰어남, 블로킹이 일어나지 않음. (2). 따라가기 어렵고 예측 불가능할 때가 있음. 에러 핸들링이 필수적

Async Await

기존의 컴플리션 핸들러 스타일의 비동기 리턴 방식을 동기적 리턴 방식으로 감싸기

private func loadImage(completion: @escaping (Result) -> ()) {
        // ... return result using completion
    }

컴플리션 핸들러 내부에 리턴할 값을 감싸야 함

private func loadImage() async throws -> UIImage {
    // ... return image

async를 따른다고 선언한 뒤 해당 파라미터를 리턴

throws는 에러를 스로우할 수 있음을 보여줌

private func testWithCompletion() {
      loadImage { result in
          switch result {
          case .success(let image):
              // handle image
              break
          case .failure(let error):
              // handle error
              break
          }
      }
  }

컴플리션 핸들러를 통해 리턴받은 값을 클로저 내부에서 관리해야 하는 이전 방식

private func testWithAsync() async {
        do {
            let image = try await loadImage()
        } catch {
            // error handling
        }
    }

async를 따른다고 선언해야 async, 비동기적으로 리턴하는 위의 함수를 사용 가능
throws를 통해 에러를 내보낼 수 있기 때문에 do catch를 통해 에러 핸들링

await를 통해 비동기적 함수의 리턴 값이 나올 때까지 기다린 뒤 원하는 태스크를 실행 가능

private func testWithAsyncAndTask() {
      Task {
          do {
              let image = try await loadImage()
          } catch {
              // error handling
          }
      }
  }

async를 통해 리턴하는 비동기 구문을 사용할 수 있는 또 다른 방법은 Task 블럭 내부에서 사용하는 것

private func testWithAsyncAsSync() async {
        do {
            let firstImage = try await loadImage()
            let secondImage = try await loadImage()
            let thridImage = try await loadImage()
        } catch {
            // error handling
        }
    }

비동기 태스크를 연속적으로 실행하는 (것처럼 보이는) 구문
실제로 비동기 함수를 위의 순차적 태스크를 하도록 하는 블럭 내부에서는 각 구문에서 서스펜션이 걸린 뒤, await를 통해 리턴을 받을 때까지 기다림. 이후 resuming이 가능한 구조

Task

태스크는 비동기적 작업의 유닛
다른 태스크의 자식이 될 수 있음
새로운 비동기 컨텍스트를 생성하도록 하는 일련의 이니셜라이저임
태스크 실행 시 실행되는 컨텍스트의 스레드를 상속할 수도, 벗어날 수도, 독립적으로 작동하는 것도 가능
Success와 Failure를 모두 제네릭하게 설정 가능

Cooperative Thread Pool

스레드 풀: 비동기 함수를 실행할 수 있는 스레드 모음
태스크는 언제나 앞으로 진행되는 프로그레스를 따르거나 서스펜션에 걸려 멈춰 있어야 함
GCD와 달리 CPU 코어 하나 당 한 개 이상이면 안 됨
스레드 과포화 상태인 thread exploision을 방지
스레드 스위칭으로 인한 오버헤드 및 퍼포먼스 패널티를 방지
여러 개의 태스크를 정지할 수 있고, 멈추 뒤 리줌을 해당 태스크 우선순위에 따라 실행 가능
Continuation: 스레드 스위칭 없이 특정 작업을 정지, 재개하는 일이 경량화됨

private func getAmazingItem() async -> UIImage? {
        // ... return data
    }

private func getFoo() async {
        let tiem = await getAmazingItem()
    }

getFoo() 함수는 getAmazingItem() 비동기 함수가 데이터를 리턴할 때까지 현재 스레드 상태를 정지한 뒤, 데이터가 리턴되면 그때 태스크를 재개
즉 현재 스레드를 '포기'한다는 것을 알려주는 것 → 스레드를 멈추거나 스레드 가용 상황과 우선순위에 따라 즉각적으로 실행할 수 있도록 설정
스레드가 멈춘 시점에 해당 리소스를 다른 태스크가 점유할 수 있기 때문에 최적화
getAmazingItem() 비동기 함수가 종료된다면, getFoo() 함수는 다시 작업을 재개하는 데, 이 싲머에서는 어느 종류의 스레드에서라도 리줌될 수 있음
스레드 과포화 상태를 방지하고 리소스 최적화를 손쉽게 달성 가능

Error Handling

async throws를 통해 발생 가능한 에러를 스로우하는 구문을 다른 태스크 / 비동기 구문에서 사용할 때 try catch를 통해 손쉽게 에러 핸들링 가능

Complier Check

    private func testWithCompletionCorrect(urlString: String, completion: @escaping ((Result) -> Void)) {
        guard let url = URL(string: urlString) else {
            completion(.failure(URLError(.badURL)))
            return
        }
        ...
    }

    private func testWithCompletionWrong(urlString: String, completion: @escaping ((Result) -> Void)) {
        guard let url = URL(string: urlString) else {
            return
        }
        ...
    }

컴플리션 핸들러를 통한 에러 핸들링의 경우 return 문과 별도로 컴플리션 클로저 내부에 실패 상황을 작성하지 않아도 컴파일러가 통과시킴

  private func testWithAsyncThrows(urlString: String) async throws -> UIImage? {
      guard let url = URL(string: urlString) else {
          throw URLError(.badURL)
      }
      ...
  }

async 구문을 통해 특정 데이터를 리턴하는 경우에는 throw 또는 리턴 데이터에 맞춰 값을 리턴해야 하기 때문에 코드를 잘못 작성하는 케이스가 감소

Async Properties

Async getters: 함수 이외의 프로퍼티에도 적용 가능.

struct Person {
    let url: URL

    var image: UIImage? {
        get async throws {
            let (data, _) = try await URLSession.shared.data(from: url)
            return UIImage(data: data)
        }
    }
}

연산 프로퍼티의 getter를 비동기적으로 작성한 구문

저장 프로퍼티의 URL을 인자로 받아 URLSession의 async를 따르는 data를 비동기적으로 리턴

private func testAsyncGetter() {
  Task {
      let person1 = Person(url: URL(string: "")!)
      let imge = try await person1.image
  }
}

해당 값을 사용하기 위해서는 동일한 방법으로 Task 또는 async를 따르는 구문 아래에서 await 작성

Asnyc / Await Scenarios

토큰 만료 이전 갱신 필요 체크: (1). 필요하다면 토큰 갱신 시도 (2). 필요없다면 그대로 놔두기 → 데이터 패치 및 리턴하기
위 상황에서 발생 가능한 에러는 거의 모든 상황에 존재(토큰 갱신 체크, 토큰을 갱신하는 과정 등)
컴플리션 핸들러를 통한 비동기 사용 → 재귀 호출이 필수 (리프레시 체크 → 그렇지 않다면 새롭게 리프레시 → 인증 토큰 발급 등이 순차적으로 이루어져야 하는데, 클로저 내부에서 또 다른 클로저를 사용해야 하기 때문에 재귀 호출을 해야 함)
async await를 통한 비동기 사용 → 재귀 호출을 사용하지 않음 (만료가 되었다면 갱신을 하는 과정이 비동기적으로 이루어지는 데, 해당 과정이 await를 통해 해당 태스크 전반을 대기시키기 때문에 그 과정이 보장이 된 시점에 해당 토큰을 곧바로 사용할 수 있기 때문)

Async let Bindings

async하게 리턴받는 과정 여러 개의 그룹을 순차적으로 실행하는 게 아니라, 병렬적으로 처리하고 싶을 때 사용 가능한 방법

기존 디스패치 그룹을 통한 enter, leave에서 벗어나 코드 가독성 및 단축

private func testWithDispatchGroup() {
  let group = DispatchGroup()
  let person1 = Person(url: URL(string: "")!)
  let person2 = Person(url: URL(string: "")!)
  let person3 = Person(url: URL(string: "")!)
  var personImages: [UIImage] = []

  group.enter()
  person1.loadImage { result in
      defer { group.leave() }
      switch result {
      case .success(let image): personImages.append(image)
      case .failure(let error): break
      }
  }
  group.enter()
  person2.loadImage { result in
      defer { group.leave() }
      switch result {
      case .success(let image): personImages.append(image)
      case .failure(let error): break
      }
  }
  group.enter()
  person3.loadImage { result in
      switch result {
      case .success(let image): personImages.append(image)
      case .failure(let error): break
      }
  }
  group.notify(queue: DispatchQueue.main) {
      handleImages(images: personImages)
  }
}

컴플리션 핸들러를 통해 비동기 데이터를 사용한다면 디스패치 그룹을 사용할 수 있음
notifiy를 통해 특정 작업이 완료되었음을 감지 가능 → 해당 블럭에서의 images 배열은 각 비동기 블럭이 완료된 이후임을 보장할 수 있음

에러 핸들링이 어렵다는 단점

func loadImage(completion: @escaping((Result) -> Void)) {
      URLSession.shared.dataTask(with: url) { data, _, error in
          if let error = error {
              completion(.failure(error))
          } else if
              let data = data,
              let image = UIImage(data: data) {
              completion(.success(image))
          }
      }
  }

이스케이핑 클로저를 통해 결과를 리턴하는 전형적인 비동기 구문

private func testWithAsyncLetBinding() async {
    let person1 = Person(url: URL(string: "")!)
    let person2 = Person(url: URL(string: "")!)
    let person3 = Person(url: URL(string: "")!)

    async let image1 = person1.image
    async let image2 = person2.image
    async let image3 = person3.image

    do {
        try await handleImages(images: [image1, image2, image3])
    } catch {
        // error handling
    }

}

각 비동기 구문을 병렬적으로 처리하되, 오로지 모든 태스크가 완료된 이후에 handleImages 함수가 실행되는 게 보장 (await를 통해 해당 handleImages로 들어오는 image1... 들이 들어올 때까지 기다림)

Cancellation

비동기적으로 시작된 특정 태스크를 중도 취소할 수 있음
Cooperative Cancellation 메커니즘을 사용
특정 비동기 요청 중간에 해당 태스크를 취소할 수 있어야 함 → 리소스를 절약하고 불필요한 네트워킹을 방지
```
try Task.checkCancellation()
```
해당 구문을 통해 해당 태스크가 중도 취소되었다면 에러를 스로우
```
if Task.isCancelled {
              // .. default value returned
          }
```
디폴트 값을 리턴하도록 캔슬 여부를 체크할 수도 있음

캔슬 상황에서 특정 구문을 실행하도록 핸들러를 제공

var image: UIImage? {
      get async throws {
          try await withTaskCancellationHandler(operation: {
              let (data, _) = try await URLSession.shared.data(from: url)
              return UIImage(data: data)
          }, onCancel: {
              // ... handle someithing in this return Void clousre
          })
      }
  }

Task Groups

여러 개의 async 리퀘스트를 보낸 뒤 리턴받은 모든 데이터를 한 번에 사용해야 하는 경우

private func testWithForLoop(people: [Person]) async -> [UIImage?] {
  var result = [UIImage?]()
  for person in people {
      do {
          try await result.append(person.image)
      } catch {
          // error handling
      }
  }
  return result
}

For-Loop를 통해 파라미터로 들어온 각 변수 별로 await를 통해 데이터가 리턴받을 때까지 서스펜션이 걸리기 때문에 병렬 처리가 아님

컨커런트한 태스크 수행이 필요하다면 앞서 언급된 async let binding이 필요

private func testWithAsyncLetBinding(people: [Person]) async -> [UIImage?] {
  var result = [UIImage?]()
  for person in people {
      async let image = person.image
      // ... cannot handle this image
  }
  return result
}

async ley으로 바인딩되는 변수의 개수가 동적으로 변할 경우 해당 인자에 대한 직접적인 접근이 어려워진다는 한계

private func testWithTaskGroups(people: [Person]) async -> [UIImage?] {
  await withTaskGroup(of: UIImage?.self, body: { group in
      for person in people {
          group.addTask {
              do {
                  let image = try await person.image
                  return image
              } catch {
                  // error handling
                  return nil
              }
          }
      }
      var result = [UIImage?]()
      for await image in group {
          result.append(image)
      }
      return result
  })
}

태스크 자체를 그룹화하여 컨커런트하게 실행한다는 아이디어
자식 태스크를 가질 수 있는 여러 개의 태스크를 묶어서 실행
withTaskGroup 내부에서 어떤 종류의 데이터 타입을 취급하는 넣어준 뒤, 바디에서 그룹으로 실행할 같은 종류의 태스크를 태스크 그룹에 넣기
태스크로 들어갈 때 클로저로 리턴하는 값이 of 뒤에 선언한 해당 데이터와 일치해야 함. 에러 핸들링 또한 do catch문을 동일하게 적용

for await를 통해 해당 그룹 태스크가 컨커런트하게 리턴하는 image를 그때마다 받아와서 결과 result를 리턴 가능

private func testWithTaskGroups(people: [Person]) async -> [UIImage?] {
  await withTaskGroup(of: UIImage?.self, body: { group in
      for person in people {
          group.addTask(priority: person.isPrior ? .high : nil) {
              do {
                  let image = try await person.image
                  return image
              } catch {
                  // error handling
                  return nil
              }
          }
      }
      var result = [UIImage?]()
      for await image in group {
          result.append(image)
      }
      return result
  })
}

* 태스크 그룹에 태스크를 추가할 때 특정 변수에 따라 우선순위 또한 설정 가능
* 여러 개의 태스크를 동시적으로 수행할 때 우선순위가 높은 태스크를 먼저 실행

```swift
private func testWithTaskGropus(people: [Person]) async -> [String: UIImage?] {
    await withTaskGroup(of: (String, UIImage?).self, body: { group in
        for person in people {
            group.addTask {
                do {
                    return try await (person.id, person.image)
                } catch {
                    return (person.id, nil)
                }
            }
        }
        return await group.reduce(into: [String: UIImage?]()) { $0[$1.0] = $1.1 }
    })
}

태스크의 결과가 동시적으로 리턴되기 때문에 결과 값을 최종 리턴하기 이전 정렬을 하는 방법이 유용함
키가 되는 값을 리턴 데이터 타입과 함께 of로 넘겨버리는 방법에 주목
Hierarchy
태스크 그룹이 존재하고, 해당 그룹에 추가된 자식 태스크가 동시적으로 실행
부모/자식 태스크가 없이 분리된 별도의 태스크를 생성 가능 → Task.detached 등을 통해 사용, 별도로 관리
Async Sequences
여러 개의 값을 리턴하는 비동기 작업을 실행해야 할 때 사용
일반적인 스위프트의 시퀀스 타입과 동일 → 시퀀스 내 값이 모두 awaited asynchronously하다는 것만 제외한다면
태스크 그룹을 사용할 때 for await in ...를 적용한 것이 그 예시

데이터 용량이 큰 csv 파일을 구조화해 사용해야 할 때

private func fetchLineSerailly(with largeCSV: URL) async {
  Task {
      let (data, _) = try await URLSession.shared.data(for: URLRequest(url: largeCSV))
      let lines = String(data: data, encoding: .utf8)?.components(separatedBy: "\n") ?? []
      for line in lines {
          // handle line...
      }
  }
}

전체 파일을 인코딩한 뒤 결과를 for loop를 통해 핸들링

private func fetchLineAsyncSequences(with largeCSV: URL) async {
  Task {
      let (bytes, _) = try await URLSession.shared.bytes(for: URLRequest(url: largeCSV))
      for try await line in bytes.lines {
          // handle line...
      }
  }
}

bytes라는 별도의 API를 통해 컨커런트하게 접근 가능

private func handleLocalFile(with localFile: URL) async {
    Task {
        let handle = try FileHandle(forReadingFrom: localFile)
        for try await line in handle.bytes.lines {
            // handle line by line
        }
    }
}

로컬 파일을 다룰 때에도 유용하게 사용할 수 있는 방법

Actor

레이스 문제를 해결할 때 가장 간편한 해결 방법 중 한 가지
멀티 스레드 환경의 컨커런트한 데이터 접근 방법과 엮어 있음

해당 상태에 대한 자동화된 동기화 및 고립을 지원

actor DataSource {
  let items = ["A", "B", "C", "D", "E"]
  private var index = 0

  func next() {
      print(items[index])
      if items.indices.contains(index + 1) {
          index += 1
      } else {
          index = 0
      }
  }
}

private func testActor() { let dataSource = DataSource() Task.detached { await dataSource.next() } Task.detached { await dataSource.next() } Task.detached { await dataSource.next() } }

* 컨커런트하게 `next()` 함수에 접근, 호출해야 할 경우 순차적 접근이 가능하도록 `actor` 클래스에서 내장 지원
```swift
@MainActor class DataSource {
    let items = ["A", "B", "C", "D", "E"]
    private var index = 0

    func next() {
        print(items[index])
        if items.indices.contains(index + 1) {
            index += 1
        } else {
            index = 0
        }
    }
}

@MainActor private func testActor() {
    let dataSource = DataSource()
    Task.detached { await dataSource.next() }
    Task.detached { await dataSource.next() }
    Task.detached { await dataSource.next() }
}

액터의 실행 스레드가 메인 스레드에서 이루어진다는 게 필요할 때 @MainActor 프로토콜을 따름으로써 보장 가능

actor DataSource {
  let items = ["A", "B", "C", "D", "E"]
  private var index = 0

  func next() {
      print(items[index])
      if items.indices.contains(index + 1) {
          index += 1
      } else {
          index = 0
      }
  }

  nonisolated
  func check() {
      print("i'm not isolated to this thread")
  }
}

private func testActor() { let dataSource = DataSource() Task.detached {await dataSource.next()} dataSource.check() }

* 특정 함수, 특정 변수가 액터가 보장하는 스레드에 고립되어 있지 않아도 된다면 `nonisolated`를 통해 `await`로 기다리지 않아도 곧바로 호출 가능하도록 설정

## Plus
* 개발 환경 (iOS 13 이상) 체크
* 커스텀 `Continuation` 함수를 만들어 사용 가능
```swift
private func testContinuation() {
    withCheckedContinuation(<#T##body: (CheckedContinuation) -> Void##(CheckedContinuation) -> Void#>)
    withCheckedThrowingContinuation(<#T##body: (CheckedContinuation) -> Void##(CheckedContinuation) -> Void#>)
    withUnsafeContinuation(<#T##fn: (UnsafeContinuation) -> Void##(UnsafeContinuation) -> Void#>)
    withUnsafeThrowingContinuation(<#T##fn: (UnsafeContinuation) -> Void##(UnsafeContinuation) -> Void#>)
}

private func testAsyncWithCompletion(completion: @escaping((Result) -> ())) { }

private func testAsyncContinuationWithCompletion() async throws -> UIImage {
    try await withCheckedThrowingContinuation({ continuation in
        testAsyncWithCompletion { result in
            continuation.resume(with: result)
        }
    })
}

컴플리션 핸들러 리턴 방식을 async await를 따르도록 리팩터링 가능

struct Item {
    let id = UUID()
}

enum ItemChange {
    case change(Item)
    case finished
}

func checkItems(change: @escaping((ItemChange) -> ())) {
    // handle async task
}

이넘을 통해 특정 데이터의 변화를 전달, 해당 전달의 비동기 구문은 이스케이핑 클로저를 쓰고 있을 때

func checkItems() -> AsyncStream {
  AsyncStream { continuation in
      checkItems { change in
          switch change {
          case .change(let item): continuation.yield(item)
          case .finished: continuation.finish()
          }
      }
  }
}

private func testCheckItems() async { Task { for await item in checkItems() { print("Current item: (item)") } } }

* `AsyncStream`을 통해 컴플리션을 감싸서 사용 가능

## SwiftUI + Async Await
* `.task` 모디파이어를 통해 iOS 15 부터 사용 가능
* `Task`를 통해 직접적으로 iOS 13부터 사용 가능했음

## Combine & Async Await
* 컴바인의 퍼블리셔가 가지고 있는 `values` 프로퍼티를 통해 `AsyncSequence`와 동일한 작업 수행 가능
```swift
private func testCombineStyle(with numbers: AnyPublisher) {
    numbers
        .map({$0 * 2})
        .prefix(3)
        .dropFirst()
        .sink { _ in
            // handle completion
        } receiveValue: { number in
            // handle number
        }
}

전형적인 컴바인 스타일

private func testCombineAndAsync(with numbers: AnyPublisher) async {
  let publisher = numbers
      .map({$0 * 2})
      .prefix(3)
      .dropFirst()
  Task {
      for try await number in publisher.values {
          // handle number
      }
      // handle completion
  }
}

퍼블리셔의 values가 정확히 AsyncSequences와 유사하기 때문에 sink 단에서 실제로 내려오는 데이터를 for (try) await로 다룰 수 있음
AsyncSequence를 위해 애플이 기본적으로 제공하는 오퍼레이터가 현재 컴바인 오퍼레이터를 대체할 수 있다는 게 유력함.

[UIKit] UICollectionView: Prefetch

Sat, 31 Dec 2022 09:57:24 GMT

Prefetching with TableViews (2022) – iOS

Smooth TableView and CollectionView Infinite Scrolling Using Prefetch DataSource

UICollectionView: Prefetch

구현 목표

컬렉션 뷰 prefetch 함수 사용

구현 태스크

prefetch 델리게이트 함수를 통해 특정 인덱스 패스에 존재한느 모델이 사용할 네트워킹을 사전에 실행
데이터 캐시를 통한 UI 표시 효율

핵심 코드

    private var collectionView: UICollectionView!
    private var dataSource: UICollectionViewDiffableDataSource!
    private var cellRegistration: UICollectionView.CellRegistration!
    private lazy var listLayout: UICollectionViewLayout = {
        var listConfig = UICollectionLayoutListConfiguration(appearance: .insetGrouped)
        listConfig.trailingSwipeActionsConfigurationProvider = {
            [weak self] indexPath -> UISwipeActionsConfiguration? in
            guard let model = self?.dataSource.itemIdentifier(for: indexPath) else { return nil }
            return .init(actions: [.init(style: .destructive, title: "Delete", handler: { [weak self] _, _, completion in
                self?.viewModel?.delete(model: model)
                completion(true)
            })])
        }
        return UICollectionViewCompositionalLayout.list(using: listConfig)
    }()

diffable 데이터 소스를 사용하기 위해 미리 선언

스와이프 액션 설정, 셀 등록

  private func setCollectionView() {
      collectionView = .init(frame: view.bounds, collectionViewLayout: listLayout)
      collectionView.autoresizingMask = [.flexibleHeight, .flexibleWidth]
      view.addSubview(collectionView)
      collectionView.delegate = self
      collectionView.prefetchDataSource = self
      collectionView.isPrefetchingEnabled = true
      cellRegistration = .init(handler: { cell, indexPath, model in
          cell.configure(with: model)
      })
      dataSource = .init(collectionView: collectionView, cellProvider: { [weak self] collectionView, indexPath, item in
          guard let self = self else { return nil }
          let cell = collectionView.dequeueConfiguredReusableCell(using: self.cellRegistration, for: indexPath, item: item)
          self.viewModel?.prefetch(model: item)
          return cell
      })
  }

* `prefetchDataSource`를 통해 특정한 셀이 `display`되기 전에 사전 로드할 데이터를 캐치 가능
* `cellRegistration`, `dataSource`를 기존의 컬렉션 뷰 UI를 그리는 방법과 달리 컴플리셔 핸들러를 통해 설정
```swift
extension PhotosViewController: UICollectionViewDelegate {
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        let offsetY = scrollView.contentOffset.y
        guard collectionView.frame.size.height > 0 else { return }
        if offsetY + collectionView.frame.size.height >= collectionView.contentSize.height - 200 {
            viewModel?.fetchImages()
        }
    }
}

infinite scrolling을 통해 200 픽셀 정도로 현재 컬렉션 뷰 최하단 부를 스크롤할 경우 자동으로 현 시점의 쿼리한 데이터를 더 불러오도록 설정
구현 화면

다운로드로 인해 상당히 메모리 부하가 심한데, full로 설정되어 있는 이미지 파일을 그대로 다운로드받기 때문. 리사이즈 또는 다운샘플링이 필요한 순간!

[SwiftUI] ChartStocksClone: Ticker Symbol Sheet UI

Fri, 30 Dec 2022 14:40:01 GMT

Build Swift Charts Stocks App Part 3 - Ticker Symbol Sheet UI - SwiftUI iOS 16 App

ChartStocksClone: Ticker Symbol Sheet UI

구현 목표

차트 선택 시 시트 뷰 구현

구현 태스크

시트 뷰 연결 로직 구현
디테일 뷰 UI 구현
API를 통한 특정 심볼 데이터 패치 및 UI 바인딩

핵심 코드

struct StockTickerView: View {
    @StateObject var quoteViewModel: TickerQuoteViewModel
    @State private var selectedRange = ChartRange.oneDay
    @Environment(\.dismiss) private var dismiss
    var body: some View {
        VStack(alignment: .leading, spacing: 0) {
            headerView.padding(.horizontal)
            Divider()
                .padding(.vertical, 8)
                .padding(.horizontal)
            scrollView
        }
        .padding(.top)
        .background(Color(uiColor: .systemBackground))
        .task {
            await quoteViewModel.fetchQuotes()
        }
    }
}

특정 리스트 셀을 탭했을 때 모달 프레젠테이션로 프레젠트될 시트 뷰
TickerQuoteViewModel을 통해 UI로 표현할 데이터를 받아들임

task 메소드를 통해 뷰 모델이 가지고 있는 데이터 패칭

func fetchQuotes() async {
      phase = .fetching
      do {
          let response = try await stocksAPI.fetchQuotes(symbols: ticker.symbol)
          if let quote = response.first {
              phase = .success(quote)
          } else {
              phase = .empty
          }
      } catch {
          print(error.localizedDescription)
          phase = .failure(error)
      }
  }

async 함수이기 때문에 뷰 단의 task 내부에서 실행 가능
phase를 데이터 패치 중, 성공/실패, 빈 화면 유무 등 이넘으로 관리 중이며, 비동기적 흐름에 의해 변경되기 때문에 현재 상황을 UI로 곧바로 표현할 수 있음

struct MainListView: View { @EnvironmentObject private var appViewModel: AppViewModel @StateObject var quotesViewModel = QuotesViewModel() @StateObject var searchViewModel = SearchViewModel() var body: some View { tickerListView .listStyle(.plain) .overlay { overlayView } .toolbar { titleToolbar attributionToolbar } ... .sheet(item: $appViewModel.selectedTicker) { StockTickerView(quoteViewModel: .init(ticker: $0, stocksAPI: quotesViewModel.stocksAPI)) .presentationDetents([.height(560)]) } ... } }

* 선택한 데이터를 리스트로 보여주는 메인 뷰
* 시트 메소드를 통해 특정한 리스트를 클릭했을 때 전역으로 들고 있는 `appViewModel` 내부의 `selectedTicker` 퍼블리셔가 널 값이 아니라 값이 들어갈 때 자동으로 모달 프레젠트
* `presentationDetents`를 통해 iOS 최신 버전부터 도입된 하프 모달을 통해 높이 조정
```swift
@MainActor
struct SearchView: View {
    @EnvironmentObject private var appViewModel: AppViewModel
    @StateObject var quotesViewModel = QuotesViewModel()
    @ObservedObject var searchViewModel: SearchViewModel
    var body: some View {
        List(searchViewModel.tickers) { ticker in
            TickerListRowView(data: .init(symbol: ticker.symbol, name: ticker.shortname, price: quotesViewModel.priceForTicker(ticker), type: .search(isSaved: appViewModel.isAddedToMyTickers(ticker: ticker), onButtonDidTap: {
                Task { @MainActor in
                    appViewModel.toggleTicker(ticker)
                }
            })))
            .contentShape(Rectangle())
            .onTapGesture {
                Task { @MainActor in
                    appViewModel.selectedTicker = ticker
                }
            }
        }
        .background(Color(uiColor: .systemBackground))
        .listStyle(.plain)
        .refreshable {
            await quotesViewModel.fetchQuotes(tickers: searchViewModel.tickers)
        }
        .task(id: searchViewModel.tickers, {
            await quotesViewModel.fetchQuotes(tickers: searchViewModel.tickers)
        })
        .overlay {
            listSearchOverlay
        }
    }
}

서치 바의 텍스트 필드를 통해 검색할 경우 나타나는 결과 리스트 뷰
해당 리스트 뷰를 클릭했을 때에도 디테일 뷰 모달 프레젠테이션이 가능하도록 탭 제스처 구현
현재 SearchView는 메인 리스트 뷰에서 overlay를 통해 나타나고 있기 때문에 별도의 sheet 메소드를 사용할 필요가 없음
현 시점의 하위 뷰, 즉 오버레이를 하고 있는 메인 리스트 뷰에서 appViewModel이 들고 있는 selectedTicker 퍼블리셔 값을 계속해서 관찰하고 있기 때문에 해당 이벤트가 발생할 경우 모달 뷰가 프레젠트되기 때문
구현 화면

이렇게 잘 구조화된 코드를 보고 있으면 대단하다는 생각부터 든다... 자연스럽게 더 잘 이해하고, "내가" 더 잘 할 수 있기를!

[RxSwift] GithubSearchClone

Fri, 30 Dec 2022 06:11:55 GMT

ReactorKit

GithubSearchClone

구현 목표

ReactorKit 깃허브 예시 파일 중 깃허브 서치 프로젝트 클론

구현 태스크

RxSwift, RxCocoa, RxDataSources, ReactorKit 사용
깃허브 API를 통한 검색 쿼리 서비스 제공
검색 결과를 통한 테이블 뷰 RxDataSources로 구성
테이블 뷰 셀 선택 시 사파리 뷰 연결

핵심 코드

final class SearchReactor: Reactor {
    enum Action {
        case updateQuery(query: String)
        case loadNextPage
    }
    enum Mutation {
        case setQuery(query: String)
        case setRepos(repos: [String], nextPage: Int?)
        case appendRepos(repos: [String], nextPage: Int?)
        case setLoadingNextPage(isLoading: Bool)
    }
    struct State {
        var query: String = ""
        var repos: [String] = []
        var nextPage: Int?
        var isLoadingNextPage: Bool = false
    }
...
}

리액터 프로토콜을 따르는 파이널 클래스 SearchReactor는 기좀 MVVM 스타일의 뷰 모델을 대리, 액션과 상태로 각 다룰 영역을 구분한 클래스
Action을 통해 어떤 선택이 가능한지, Mutation을 통해 어떤 변화가 일어날지, State를 통해 어떤 종류의 변화가 적용이 되었는지 확인할 수 있음

    func mutate(action: Action) -> Observable {
        switch action {
        case .updateQuery(query: let query):
            return Observable.concat([
                Observable.just(Mutation.setQuery(query: query)),
                search(query: query, page: 1)
                    .take(until: self.action.filter({ action in
                        switch action {
                        case .updateQuery(query: _): return true
                        default: return false
                        }
                    }))
                    .map({Mutation.setRepos(repos: $0, nextPage: $1)})
            ])
        case .loadNextPage:
            guard
                !currentState.isLoadingNextPage,
                let page = currentState.nextPage else { return .empty() }
            return Observable.concat([
                Observable.just(Mutation.setLoadingNextPage(isLoading: true)),
                search(query: currentState.query, page: page)
                    .take(until: self.action.filter({ action in
                        switch action {
                        case .updateQuery(query: _): return true
                        default: return false
                        }
                    }))
                    .map({Mutation.appendRepos(repos: $0, nextPage: $1)}),
                Observable.just(Mutation.setLoadingNextPage(isLoading: false))
            ])
        }
    }

특정한 액션이 들어왔을 때 어떤 변화가 일어나는지 함수를 통해 표현하는 mutate

액션의 종류에 따라 어떤 변화가 일어나는지 Observable.concat을 통해 Observable의 변화를 연속적으로 붙여서 리턴하는 게 관습적인 코드인 것 같음

private func getURL(query: String, page: Int) -> URL? {
      guard !query.isEmpty else { return nil }
      var components = URLComponents(string: baseURLString)
      let urlQueryItems: [URLQueryItem] = [
          .init(name: "q", value: query.lowercased()),
          .init(name: "page", value: page.description),
          .init(name: "client_id", value: "token [YOUR_GITHUB_ACCESS_TOKEN]")
      ]
      components?.queryItems = urlQueryItems
      return components?.url
  }

private func search(query: String, page: Int) -> Observable<(repos: [String], nextPage: Int?)> { guard let url = getURL(query: query, page: page) else { return .just((repos: [], nextPage: nil))} return URLSession.shared.rx.json(url: url) .map { json -> ([String], Int?) in guard let dict = json as? [String: Any], let items = dict["items"] as? [[String: Any]] else { return ([], nil) } let repos = items.compactMap({ $0["full_name"] as? String }) let nextPage = repos.isEmpty ? nil : page + 1 return (repos, nextPage) } }

* 쿼리 검색 액션이 들어왔을 때 실행되는 검색 함수
* 깃허브 API를 사용하기 때문에 쿼리를 구성한 뒤 URL를 리턴, 해당 URL을 통해 `URLSession`을 사용한 검색 결과를 `Observable`로 감싸 리턴하는 게 검색 함수의 결과
```swift
    func reduce(state: State, mutation: Mutation) -> State {
        var state = state
        switch mutation {
        case .setQuery(query: let query):
            state.query = query
        case .setRepos(repos: let repos, nextPage: let nextPage):
            state.repos = repos
            state.nextPage = nextPage
        case .appendRepos(repos: let repos, nextPage: let nextPage):
            state.repos.append(contentsOf: repos)
            state.nextPage = nextPage
        case .setLoadingNextPage(isLoading: let isLoading):
            state.isLoadingNextPage = isLoading
        }
        return state
    }

현재 상태 및 변경 사항이 주어진다면 현재 상태가 어떻게 변화되어야 하는지 확인하는 함수
즉 reduce되는 결과값이 상태에 반영된다는 뜻

상태 구조체를 구성하는 쿼리, 레포지터리 배열, 페이지 정수, 로딩 중 여부 등 경우의 수에 따라 현재 상태 변경

typealias ReactorView = ReactorKit.View
final class SearchViewController: UIViewController, ReactorView {
  private let searchController: UISearchController = {
      let controller = UISearchController(searchResultsController: nil)
      controller.searchBar.placeholder = "Search Github Input..."
      return controller
  }()
  private let tableView: UITableView = {
      let tableView = UITableView()
      tableView.register(UITableViewCell.self, forCellReuseIdentifier: "tableViewCell")
      return tableView
  }()
  var disposeBag = DisposeBag()
  private let reactor = SearchReactor()

  override func viewDidLoad() {
      super.viewDidLoad()
      setUI()
      bind(reactor: reactor)
  }
...
}

Reactor 프레임워크의 View 프로토콜을 따르는 뷰 컨트롤러
뷰 컨트롤러, 셀 등은 모두 View로 간주하는 게 리액터 킷의 관점

bind(reacotr:) 함수는 외부에서 리액터가 주입이 될 때 곧바로 실행이 되는 데, 현 시점에서는 뷰 컨트롤러 내부에서 private하게 리액터를 가지고 있고 로드가 될 때 자동으로 바인드 함수를 실행하는 방식으로 구현

  func bind(reactor: SearchReactor) {
      searchController
          .searchBar
          .rx
          .text
          .orEmpty
          .throttle(.milliseconds(500), scheduler: MainScheduler.instance)
          .map({ SearchReactor.Action.updateQuery(query: $0)})
          .bind(to: reactor.action)
          .disposed(by: disposeBag)
      tableView
          .rx
          .contentOffset
          .filter { [weak self] offset in
              guard let self = self else { return false}
              guard self.tableView.frame.size.height > 0 else { return false }
              return offset.y + self.tableView.frame.size.height >= self.tableView.contentSize.height - 100
          }
          .map { _ in
              SearchReactor.Action.loadNextPage
          }
          .bind(to: reactor.action)
          .disposed(by: disposeBag)
      typealias SearchSection = SectionModel
      let dataSource: RxTableViewSectionedReloadDataSource = .init { _, tableView, indexPath, item in
          let cell = tableView.dequeueReusableCell(withIdentifier: "tableViewCell", for: indexPath)
          cell.textLabel?.text = item
          return cell
      }
      reactor
          .state
          .map({ $0.repos })
          .map({ [SearchSection(model: 0, items: $0)]})
          .asDriver(onErrorJustReturn: [])
          .drive(tableView.rx.items(dataSource: dataSource))
          .disposed(by: disposeBag)
      reactor
          .state
          .map({ $0.isLoadingNextPage })
          .distinctUntilChanged()
          .observe(on: MainScheduler.instance)
          .subscribe { [weak self] isLoading in
              guard let self = self else { return }
              self.tableView.tableFooterView = isLoading ? self.createSpinnerView() : nil
          }
          .disposed(by: disposeBag)
      tableView
          .rx
          .itemSelected
          .subscribe { [weak self, weak reactor] indexPath in
              guard let self = self else { return }
              self.view.endEditing(true)
              self.tableView.deselectRow(at: indexPath, animated: true)
              guard
                  let repo = reactor?.currentState.repos[indexPath.row],
                  let url = URL(string: "https://www.github.com/\(repo)") else { return }
              let vc = SFSafariViewController(url: url)
              self.searchController.present(vc, animated: true)
          }
          .disposed(by: disposeBag)
  }

* `ReactorKit`과 별개로 `rx`를 통해 뷰를 그리는 파트
* 서치 바의 텍스트를 `rx`화하여 반응형으로 리액터의 쿼리를 업데이트하는 액션과 연동
* 테이블 뷰의 `contentOffset` 또한 반응형으로 감지, 특정 오프셋 이상이 넘길 때 (즉 스크롤을 마지막까지 당긴 뒤 계속해서 로드할 때) 다음 결과를 쿼리하라는 액션으로 바인딩
* 리액터의 각 상태값이 들고 있는 레포지터리 배열 데이터, 로딩 여부 등을 통해 테이블 뷰의 데이터 소스를 그리거나 푸터 뷰에 로딩 뷰를 잠시 보여줄 것인지 또한 구현
* 선택된 테이블 뷰 셀이 있다면 해당 셀로부터 사파리 웹뷰를 구성, 연결

## 구현 화면
![](https://velog.velcdn.com/images/j_aion/post/5e644821-dbec-46fd-a6fe-2f6ed76e550c/image.gif)

[RxSwift] AirPortClone: MapKit

Thu, 29 Dec 2022 07:10:33 GMT

#12 Adding Pins to Map using MapKit - RxSwift MVVM Coordinator iOS App

AirPortClone: MapKit

구현 목표

구현 태스크

맵뷰 구현
맵뷰 어노테이션 뷰 구현
현재 위치 - 해당 위치 경로 구현

핵심 코드

protocol AirportDetailsViewPresentable {
    typealias Input = ()
    typealias Output = (
        airportDetails: Driver,
        mapDetails: Driver
    )
    typealias Dependencies = (
        model: AirportModel,
        currentLocation: Observable<(lat: Double, lon: Double)?>
    )

    var input: AirportDetailsViewPresentable.Input { get }
    var output: AirportDetailsViewPresentable.Output { get }

    typealias ViewModelBuilder = (AirportDetailsViewPresentable.Input) -> (AirportDetailsViewPresentable)
}

맵뷰와 함께 해당 공항의 정보를 표현할 뷰에 해당할 뷰 모델 프로토콜

인풋을 통해 뷰 모델 자체를 리턴하는 뷰 모델 빌더 및 아웃풋을 구성하기 위한 디펜던시

  private static func transform(input: AirportDetailsViewPresentable.Input, dependencies: AirportDetailsViewPresentable.Dependencies) -> AirportDetailsViewPresentable.Output {
      let airportDetails: Driver = dependencies
          .currentLocation
          .compactMap({ $0 })
          .map { [airportModel = dependencies.model] currentLocation in
              AirportViewModel(model: airportModel, currentLocation: currentLocation)
          }
          .asDriver(onErrorDriveWith: .empty())
      let mapDetails: Driver = dependencies
          .currentLocation
          .compactMap({ $0 })
          .map { [airportModel = dependencies.model] currentLocation in
              guard
                  let lat = Double(airportModel.lat),
                  let lon = Double(airportModel.lon) else { throw URLError(.badURL) }

              return AirportMapViewModel(airportLocation: (lat: lat, lon: lon), airport: (name: airportModel.name, city: airportModel.city), currentLocation: currentLocation)
          }
          .asDriver(onErrorDriveWith: .empty())
      return (
          airportDetails: airportDetails,
          mapDetails: mapDetails
      )
  }

* 건네받은 디펜던시의 값을 통해 공항 정보 및 맵 뷰 정보를 업데이트 → `Driver`로 캐스팅해서 UI 업데이트에 적용
```swift
import Foundation

protocol AirportMapViewPresentable {
    var airport: (name: String, city: String) { get }
    var currentLocation: (lat: Double, lon: Double) { get }
    var airportLocation: (lat: Double, lon: Double) { get }

}

맵뷰를 그릴 때 사용할 별도의 프로토콜

private var viewModel: AirportDetailsViewPresentable?
  var viewModelBuilder: AirportDetailsViewPresentable.ViewModelBuilder!

뷰 컨트롤러에서 private으로 숨긴 뷰 모델과 달리 외부 접근 가능한 뷰 모델 빌더

override func start() {
      let vc = AirportDetailsViewController()
      let locationService = LocationService.shared
      vc.viewModelBuilder = {
          AirportDetailsViewModel(input: $0, dependencies: (model: self.model, currentLocation: locationService.currentLocation))
      }
      router.present(vc, isAnimated: true, onDismiss: isCompleted)
  }

디테일 뷰 컨트롤러를 coordinator에 띄우는 단계인 start() 함수에서 외부 접근 가능한 뷰 모델 빌더의 클로저를 현 시점에서 선언

뷰 모델을 만들 때 필요한 인풋 및 디펜던시가 존재하는 공간이 현재 coordinator이기 때문

  private func bind() {
      viewModel?.output
          .airportDetails
          .map({ [weak self] viewModel in
              self?.nameLabel.text = viewModel.name
              self?.distanceLabel.text = viewModel.formattedDistance
              self?.countryLabel.text = viewModel.address
              self?.lengthLabel.text = viewModel.runwayLength
          })
          .drive()
          .disposed(by: disposeBag)
      viewModel?.output
          .mapDetails
          .map({ [weak self] viewModel in
              let currentPoint = CLLocationCoordinate2D(latitude: viewModel.currentLocation.lat, longitude: viewModel.currentLocation.lon)
              let airportPoint = CLLocationCoordinate2D(latitude: viewModel.airportLocation.lat, longitude: viewModel.airportLocation.lon)
              let currentPin = AirportPin(name: "Current", coordinate: currentPoint)
              let airportPin = AirportPin(name: viewModel.airport.name, city: viewModel.airport.city, coordinate: airportPoint)
              self?.mapView.addAnnotations([currentPin, airportPin])
              print("MapView add annotations")
              let currentPlacemark = MKPlacemark(coordinate: currentPoint)
              let destinationPlacemark = MKPlacemark(coordinate: airportPoint)
              let directionRequest = MKDirections.Request()
              directionRequest.source = MKMapItem(placemark: currentPlacemark)
              directionRequest.destination = MKMapItem(placemark: destinationPlacemark)
              directionRequest.transportType = .automobile
              let directions = MKDirections(request: directionRequest)
              directions.calculate { response, error in
                  guard
                      let route = response?.routes.first,
                      error == nil else { return }
                  self?.mapView.addOverlay(route.polyline
                                           , level: .aboveRoads)
                  UIView.animate(withDuration: 1) {
                      let mapRect = route.polyline.boundingMapRect
                      let region = MKCoordinateRegion(mapRect)
                      self?.mapView.setRegion(region, animated: true)
                  }
              }
          })
          .drive()
          .disposed(by: disposeBag)
  }

* `Driver`에 의해 관찰 가능한 데이터가 들어올 때 바인딩되는 곳
* 스택 뷰에 해당 맵뷰의 정보를 라벨로 들여보내고, 커스텀 맵 어노테이션을 통해 해당 위치를 맵뷰에 표시, 현재 위치와의 경로 등을 표현

## 구현 화면
![](https://velog.velcdn.com/images/j_aion/post/f3b411b3-696e-454d-bb71-c8b95883ad1b/image.gif)

[RxSwift] AirPortClone: Modal Presentation

Wed, 28 Dec 2022 16:58:16 GMT

#11 Present and Dismiss a ViewController in Coordinator - RxSwift MVVM Coordinator iOS App

구현 목표

coordinator 패턴에서의 모달 전환 구현

구현 태스크

Routing 프로토콜 내 모달 프레젠트 및 디스미스 함수 구현
클로저를 통한 디스미스 시 메모리 누수 방지

핵심 코드

protocol RouterProtocol {
    func push(_ drawable: Drawable, isAnimated: Bool, onNavigationBack: NavigationBackClosure?)
    func pop(_ isAnimated: Bool)
    func popToRoot(_ isAnimated: Bool)
    func present(_ drawable: Drawable, isAnimated: Bool, onDismiss: NavigationBackClosure?)
}

라우팅을 담당하는 프로토콜 내 present 함수 추가

func present(_ drawable: Drawable, isAnimated: Bool, onDismiss closure: NavigationBackClosure?) {
      guard let viewController = drawable.viewController else { return }
      if let closure = closure {
          closures.updateValue(closure, forKey: viewController.description)
      }
      navigationController.present(viewController, animated: isAnimated)
      viewController.presentationController?.delegate = self
  }

해당 프로토콜을 따르는 라우터 클래스에서 해당 함수는 즉 모달로 프레젠트된 뷰 컨트롤러와 함께 파라미터로 건네받은 디스미스 클로저를 딕셔너리에 기록해두는 것, 즉 이전의 네비게이션 이동과 동일한 로직
```
extension Router: UIAdaptivePresentationControllerDelegate {
  func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
      executeClosures(presentationController.presentedViewController)
  }
}
```
프레젠테이션 컨트롤러 델리게이트를 따름으로써 presentationControllerDidDismiss 함수를 사용 가능

모달 뷰가 사라졌을 때 executeClosures()를 사용함으로써 딕셔너리에 기록해놓은 클로저가 해당 라우터 클래스에서 실행됨

private func showAirportDetails(model: AirportModel) {
      let detailCoordinator = AirportDetailsCoordinator(router: router)
      add(coordinator: detailCoordinator)

      detailCoordinator.isCompleted = { [weak self, weak detailCoordinator] in
          guard let detailCoordinator = detailCoordinator else { return }
          self?.remove(coordinator: detailCoordinator)
      }
      detailCoordinator.start()
  }

모달 전환이 이루어지는 곳은 테이블 뷰의 각 셀을 구현하는 AirportsCoordinator에서 클릭 이벤트가 발생하는 곳
detailCoordinator라는 새로운 전환이 일어날 때 isCompleted - 즉 onDismiss 클로저에 파라미터로 들어갈 클로저를 선언

coordinator에 들어간 메모리를 다시 제거해주는 장소

override func start() {
      let vc = AirportDetailsViewController()
      router.present(vc, isAnimated: true, onDismiss: isCompleted)
  }

AirportsCoordinator에서 작동하는 start() 함수
실제 라우터 클래스의 present 함수가 실행되는 코드

private func setViewModel() {
        viewModel = viewModelBuilder((
            selectAirport: tableView.rx.modelSelected(AirportViewPresentable.self).asDriver(onErrorDriveWith: .empty()), ()
        ))
    }

AirportsViewController에서 해당 setViewModel 함수가 실행되는 구문
tableView.rx.modelSelected를 통해 반응형으로 현재 유저가 선택한 셀의 모델(AirportViewPresentable)을 뷰 모델 빌더에게 넘겨줄 수 있음

typealias Input = (
        selectAirport: Driver, ()
    )

뷰 모델이 따르는 프레젠터블 프로토콜의 인풋

private typealias RoutingAction = (airportSelectRelay: PublishRelay, ())
    private let routingAction = (airportSelectRelay: PublishRelay(), ())
    typealias Routing = (airportSelect: Driver, ())
    lazy var router: Routing = (airportSelect: routingAction.airportSelectRelay.asDriver(onErrorDriveWith: .empty()), ())

뷰 모델의 라우팅 액션 / 라우팅은 각각 이동할 뷰 컨트롤러가 가질 뷰 모델을 구성하는 역할

private으로 감싸 놓은 Relay를 통해 Driver를 만들어주는 역할

func process(dependencies: Dependencies) {
      input
          .selectAirport
          .map { [models = dependencies.models] viewModel in
              models.filter({ $0.code == viewModel.code}).first
          }
          .compactMap({ $0 })
          .map({ [routingAction] in
              routingAction.airportSelectRelay.accept($0)
          })
          .drive()
          .disposed(by: disposeBag)
  }

입력된 Set 가운데 입력된 모델과 코드가 일치하는 모델만 필터링, 라우팅 액션 Relay에 값을 들여보내는 곳
구현 화면

[RxSwift] AirPortClone: Handling Memory Leak

Wed, 28 Dec 2022 16:11:42 GMT

#10 Handling Memory Leak on Back of ViewController - RxSwift MVVM Coordinator iOS App

AirPortClone: Handling Memory Leak

구현 목표

Rx 및 Coordinator 패턴 사용 시 발생 가능한 메모리 누수 방지

구현 태스크

Coordinator 패턴 사용 시 발생하는 child 관리 문제 해결
커스텀 네비게이션 푸시/팝 구현

핵심 코드

protocol Drawable {
    var viewController: UIViewController? { get }
}

extension UIViewController: Drawable {
    var viewController: UIViewController? { return self }
}

모든 뷰 컨트롤러가 Drawable이라는 커스텀 프로토콜을 따르도록 선언
해당 viewController 변수는 자기 자신을 리턴하는 옵셔널 변수
드로우, 즉 뒤로 되돌릴 수 있는(백) 종류의 뷰 컨트롤러라는 뜻
```
typealias NavigationBackClosure = (() -> ())
```

protocol RouterProtocol { func push(_ drawable: Drawable, isAnimated: Bool, onNavigationBack: NavigationBackClosure?) func pop(_ isAnimated: Bool) }

* 네비게이션과 관련된 커스텀 프로토콜
* `Drawable`, 즉 뷰 컨트롤러 또한 해당 파라미터로 들어올 수 있으며 클로저 또한 함께 받기
* `onNavigationBack`에서는 네비게이션 백 버튼이 눌릴 때의 행동 또한 함께 규정 가능
```swift
final class Router: NSObject {
    private let navigationController: UINavigationController
    private var closures: [String: NavigationBackClosure] = [:]

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
        super.init()
        self.navigationController.delegate = self
    }
}

네비게이션 푸쉬/팝을 드라이브하는 주체
이니셜라이즈할 때 네비게이션 컨트롤러를 받기
클래스 내부 private으로 클로저를 딕셔너리로 가지고 있음

뷰 컨트롤러의 description을 통해 해다 클로저를 찾을 수 있음

extension Router: RouterProtocol {
  func push(_ drawable: Drawable, isAnimated: Bool, onNavigationBack closure: NavigationBackClosure?) {
      guard let viewController = drawable.viewController else { return }
      if let closure = closure {
          closures.updateValue(closure, forKey: viewController.description)
      }
      navigationController.pushViewController(viewController, animated: isAnimated)
  }

func pop(_ isAnimated: Bool) {
    navigationController.popViewController(animated: isAnimated)
}

func executeClosures(_ viewController: UIViewController) {
    guard let closure = closures.removeValue(forKey: viewController.description) else { return }
    closure()
}

}

* 라우터 프로토콜을 따르는 해당 라우터 클래스는 푸쉬 함수에서 파라미터로 건네받은 네비게이션 컨트롤러에 뷰 컨트롤러를 딕셔너리에 기록
* 클로저를 실행하는 코드 역시 딕셔너리를 통해 사용
```swift
extension Router: UINavigationControllerDelegate {
    func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool) {
        guard let previousController = navigationController.transitionCoordinator?.viewController(forKey: .from) else {
            return
        }
        guard !navigationController.viewControllers.contains(previousController) else {
            return
        }
        executeClosures(previousController)
    }
}

이니셜라이즈 당시 입력받은 네비게이션 컨트롤러의 델리게이트 함수 중 didShow를 통해, 네비게이션이 나타났을 때 이전 뷰 컨트롤러를 찾아낼 수 있음
두 번째 gaurd 문은 더 이상 현재 네비게이션 컨트롤러가 해당 뷰 컨트롤러를 가지고 있지 않음을 다시 한 번 확인하는 코드. 즉 메모리에 남아 있지 않아야 하는 뷰 컨트롤러야만 한다는 뜻

이제 사라져야 마땅한 뷰 컨트롤러라면, 해당 뷰 컨트롤러를 받아들일 때 백 버튼 관련 클로저를 실행해야 한다는 뜻

class BaseCoordinator: Coordinator {
  var childCoordinator: [Coordinator] = []
  var isCompleted: (()->())?

  func start() {
      fatalError("Children should be implemented in start func")
  }
}

모든 Coordinator가 기본으로 따르는 BaseCoordinator 클래스

isCompleted는 onNavigationBack 파라미터에서 구현될 커스텀 클로저, 현재는 널 값

override func start() {
      let router = Router(navigationController: self.navigationController)
      let searchCoordinator = SearchCoordinator(router: router)
      self.add(coordinator: searchCoordinator)
      searchCoordinator.isCompleted = { [weak self, weak searchCoordinator] in
          guard let coordinator = searchCoordinator else { return }
          self?.remove(coordinator: coordinator)
      }
      searchCoordinator.start()
      window.rootViewController = navigationController
      window.makeKeyAndVisible()
  }

가장 하단 부에서 뷰 컨트롤러 이동 등을 담당하는 AppCoordinator 클래스의 start() 함수
add를 통해 이제 네비게이션 이동에 추가할 자식 coordinator에 값을 추가한다면, 반대로 백 버튼 등 네비게이션 팝을 했을 때 자식 coordinator 값 또한 제거해야 함
isCompleted 클로저에서 해당 뷰 컨트롤러가 팝될 때 현재까지 기록된 child에서 해당 coordinator를 제거해주기로 함

네비게이션 푸시/팝 등 최하단 부에서 자동으로 관리해주던 영역까지 coordinator를 통해 관리해주어야 한다. (왜냐하면 coordinator 패턴을 따를 때 현 시점에서는 모든 이동 과정 역시 커스텀으로 구현한 coordinator 클래스에서 관리해주고 있기 때문이다. 무엇이 우선일까...?

[RxSwift] AirPortClone: CoreLocation

Wed, 28 Dec 2022 15:20:15 GMT

#9 Distance Calculation using CoreLocation - RxSwift MVVM Coordinator iOS App

AirPortClone: CoreLocation

구현 목표

CoreLocation을 통한 현재 위치 및 거리 측정 로직 구현

구현 태스크

현재 위치와 특정 위치 간의 계산 자동화

핵심 코드

final class LocationService: NSObject {
    static let shared = LocationService()
    private let manager = CLLocationManager()
    private let currentLocationRelay: BehaviorRelay<(lat: Double, lon: Double)?> = .init(value: nil)
    lazy var currentLocation: Observable<(lat: Double, lon: Double)?> = self.currentLocationRelay.asObservable().share(replay: 1, scope: .forever)

    private override init() {
        super.init()
        setLocationService()
    }

    private func setLocationService() {
        manager.delegate = self
        manager.desiredAccuracy = kCLLocationAccuracyBestForNavigation
        manager.requestAlwaysAuthorization()

        if CLLocationManager.locationServicesEnabled() {
            manager.startUpdatingLocation()
        }
    }

    deinit {
        manager.stopUpdatingLocation()
    }
}

extension LocationService: CLLocationManagerDelegate {
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.last else { return }
        let currentLocation = (lat: location.coordinate.latitude, lon: location.coordinate.longitude)
        currentLocationRelay.accept(currentLocation)
        manager.stopUpdatingLocation()
    }
}

currentLocationRelay는 BehaviorRelay 타입으로 지역을 표현하는 튜플을 담아두는 릴레이
Observable을 통해 해당 지역 튜플 데이터 관찰 가능
didUpdateLocations를 통해 건네받은 현재 위치를 currentLocationRelay로 넘기기

싱글턴 패턴 구현

override func start() {
      let vc = AirportsViewController()
      let locationService = LocationService.shared
      vc.viewModelBuilder = { [models] in
          let title = models.first?.city ?? ""
          return AirportsViewModel(input: $0, dependencies: (title: title, models: models, currentLocation: locationService.currentLocation))
      }
      self.navigationController.pushViewController(vc, animated: true)
  }

AirportsCoordinator에서 start()를 통해 다른 뷰 컨트롤러를 시동하는 구조

dependencies를 통해 뷰 모델을 빌드하고 있는데, 현 시점의 currentLocation을 읽어오는 곳이 바로 현 시점.

private static func getDistance(airportLocation: (lat: Double?, lon: Double?),
                           currentLocation: (lat: Double, lon: Double)) -> Double? {
      guard
          let lat = airportLocation.lat,
          let lon = airportLocation.lon else { return nil }
      let current = CLLocation(latitude: currentLocation.lat, longitude: currentLocation.lon)
      let airport = CLLocation(latitude: lat, longitude: lon)
      return current.distance(from: airport)
  }

API를 통해 읽어온 데이터와 현재 위치 값의 거리를 자동으로 계산해서 리턴하는 static 함수

self.distance = AirportViewModel.getDistance(airportLocation: (lat: Double(model.lat), lon: Double(model.lon)), currentLocation: currentLocation)

해당 함수를 통해 뷰 모델의 distance 값이 자동으로 계산

extension AirportViewModel: Comparable {
  static func < (lhs: AirportViewModel, rhs: AirportViewModel) -> Bool {
      return lhs.distance ?? 0 < rhs.distance ?? 0
  }

  static func == (lhs: AirportViewModel, rhs: AirportViewModel) -> Bool {
      return lhs.code == rhs.code
  }
}

현재 Comparable 프로토콜을 준수하는 뷰 모델은 <, == 함수를 적용했기 때문에 이후 여러 개의 거리를 가진 뷰 모델이 테이블 뷰에 들어오기 전 sorted로 정렬 가능한 형태

구현 화면

[RxSwift] AirPortClone: UITableView & RxDataSources

Wed, 28 Dec 2022 07:48:34 GMT

#8 Airports UITableView Binding using RxDatasources - RxSwift MVVM Coordinator iOS App

AirPortClone: UITableView & RxDataSources

구현 목표

RxDataSources를 통한 테이블 뷰 구현

구현 태스크

커스텀 테이블 뷰 구현

핵심 코드

typealias AirportItemsSection = SectionModel

protocol AirportsViewPresentable {
    typealias Input = (
    )
    typealias Output = (
        title: Driver,
        airports: Driver<[AirportItemsSection]>
    )
    typealias Dependencies = (
        title: String,
        models: Set
    )
    typealias ViewModelBuilder = (AirportsViewPresentable.Input) -> AirportsViewPresentable

    var input: AirportsViewPresentable.Input { get }
    var output: AirportsViewPresentable.Output { get }
}

뷰 모델 빌더는 인풋을 받아 현재 프로토콜 자체를 리턴

뷰 모델이 해당 AirportsViewPresentable을 따르기 때문에 사용 가능

override func start() {
      let vc = AirportsViewController()
      vc.viewModelBuilder = { [models] in
          let title = models.first?.city ?? ""
          return AirportsViewModel(input: $0, dependencies: (title: title, models: models))
      }
      self.navigationController.pushViewController(vc, animated: true)
  }

뷰 모델 빌더의 클로저를 현재 AirportsCoordinator에서 넣어줌

뷰 컨트롤러를 바인딩할 때 사용했던 데이터 모델 집합을 통해 뷰 모델을 구현

private func configureDataSource() {
      dataSource = .init(configureCell: { _, tableView, indexPath, item in
          guard let cell = tableView.dequeueReusableCell(withIdentifier: AirportTableViewCell.identifier, for: indexPath) as? AirportTableViewCell else { fatalError() }
          cell.configure(with: item)
          return cell
      })
  }

RxDataSources가 제공하는 섹션 모델을 커스텀, 해당 섹션 모델을 통해 데이터 소스를 구성

데이터 소스를 표현하는 클로저 내부에서 실제 셀 UI 구성

private func bind() {
      guard let dataSource = dataSource else { return }
      viewModel?
          .output
          .airports
          .drive(tableView.rx.items(dataSource: dataSource))
          .disposed(by: disposeBag)
      viewModel?
          .output
          .title
          .drive(rx.title)
          .disposed(by: disposeBag)
  }

dataSource를 통해 테이블 뷰 UI 표현
rx.title은 뷰 컨트롤러 자체의 타이틀을 반응형으로 보여주는 듯
구현 화면

Coordinator 내에서 뷰 컨트롤러와 뷰 모델을 빌드, 연결하는 과정에 점점 더 익숙해지는 것 같긴 한데...

[RxSwift] AirPortClone: UITableViewCell & AirportViewModel

Wed, 28 Dec 2022 06:46:08 GMT

#7 UITableViewCell Binding using AirportViewModel - RxSwift MVVM Coordinator iOS App

AirPortClone: UITableViewCell & AirportViewModel

구현 목표

커스텀 테이블 뷰 셀 구현

구현 태스크

테이블 뷰 셀 구현
UI 바인딩 함수 구현
뷰 모델 구현

핵심 코드

protocol AirportViewPresentable {
    var name: String { get }
    var code: String { get }
    var address: String { get }
    var distance: Double? { get }
    var formattedDistance: String { get }
    var runwayLength: String { get }
    var location: (lat: String, lon: String) { get }
}

뷰 모델이 따를 프로토콜

extension AirportViewModel {
  init(model: AirportModel) {
      self.name = model.name
      self.code = model.code
      self.address = "\(model.state ?? ""), \(model.country)"
      self.runwayLength = "Runway Length: \(model.runwayLength ?? "NA")"
      self.location = (lat: model.lat, lon: model.lon)
      self.distance = 0
  }
}

데이터 모델을 파라미터로 받아 해당 프로토콜의 값을 이니셜라이즈하는 뷰 모델

func configure(with model: AirportViewModel) {
      nameLabel.text = model.name
      distanceLabel.text = model.formattedDistance
      countryLabel.text = model.address
      lengthLabel.text = model.runwayLength
  }

해당 뷰 모델을 통해 UI를 그리는 configure 함수

강의의 주요 태스크는 _view_presentable이라는 프로토콜을 만든 뒤, 해당 프로토콜을 따르는 구조체(!)를 뷰 모델로 설정, 해당 뷰 모델을 통해 뷰 컨트롤러의 데이터를 담당하는 것인데, 과연 기존의 클래스를 직접 뷰 모델로 넣는 것과 무엇이 다른 것인지, 그저 프로토콜 지향 프로그래밍의 일종인 것인지 궁금하다.

[UIKit] Concurrency: Actor

Tue, 27 Dec 2022 10:12:39 GMT

Concurrency using Actors | Swift 5.5 | Async/Await | Data Race

Concurrency: Actor

Race Problem

두 개 이상의 비동기 태스크가 여러 스레드에서 실행될 경우 data inconsistency 발생할 수 있음.
레이스 문제를 해결하기 위한 방법 중 스레드 세이프를 보장하는 방법이 존재

class Flight {
    let company = "Luft Hansa"
    var availableSeats = ["1A", "1B", "1C"]
    func getAvailableSeats() -> [String] {
        availableSeats
    }
    func bookSeat() -> String {
        return availableSeats.removeFirst()
    }
}

한정된 데이터가 존재하고 특정 함수를 통해 해당 데이터를 사용, 변경되는 경우

private func testFlightProblem1() {
      let flight = Flight()
      let queue1 = DispatchQueue(label: "queue1")
      let queue2 = DispatchQueue(label: "queue2")

      queue1.async {
          let bookedSeat = flight.bookSeat()
          print("Booked seat is \(bookedSeat)")
      }
      queue2.async {
          let availableSeats = flight.getAvailableSeats()
          print("Available Seats \(availableSeats)")
      }
  }

두 개 이상의 서로 다른 스레드에서 해당 함수를 사용해 동일한 데이터에 접근할 경우 레이스 문제 발생 가능
```
Booked seat is 1A
Available Seats ["1A", "1B", "1C"]
```
첫 번째 큐에서 작성한 태스크와 두 번째 큐에서 작성한 태스크가 동일한 데이터를 건드리고 있지만 비동기적으로 작동하기 때문에 태스크가 끝나고 나서 시작한 지 보장할 수 없음

DispatchQueue: Barrier Flag

배리어 플래그를 통해 이후 태스크를 실행할 스레드의 실행을 '블럭'시킬 수 있음

class Flight {
  let company = "Luft Hansa"
  var availableSeats = ["1A", "1B", "1C"]
  let barrierQueue: DispatchQueue = DispatchQueue(label: "barrierQueue", attributes: .concurrent)
  func getAvailableSeats() -> [String] {
      barrierQueue.sync(flags: .barrier) {
          return availableSeats
      }
  }
  func bookSeat() -> String {
      barrierQueue.sync(flags: .barrier) {
          return availableSeats.removeFirst()
      }
  }
}

컨커런트한 배리어 큐를 별도로 실행한 뒤, 레이스 문제가 발생할 수 있는 구문을 해당 큐의 배리어 플래그가 추가된 상태에서 실행
```
Booked seat is 1A
Available Seats ["1B", "1C"]
```

Actor

참조 타입, 프로토콜, 제네릭 등을 사용 가능하다는 점에서 클래스와 매우 유사. 상속 또한 사용 가능. 하지만 data inconsistency와 같은 동시성 문제를 신경쓸 필요가 없음
액터 내부 데이터: let, var과 같은 데이터의 가변성에도 영향을 받음 - 상수라면 문제 없이 참조 가능하지만, 값이 바뀔 수 있는 변수라면 별도의 블럭을 추가해야 함
저장 프로퍼티가 아니라 연산 프로퍼티라면 동일한 문제 발생 (var임)
nonisolated라는 키워드를 통해 컴파일러에게 해당 데이터는 var임에도 불구하고 let과 같이 레이스 문제가 일어나지 않는다고 강제할 수 있음
async await와 함께 액터 값을 조회/참조/변경 가능
Task 블럭 내부 비동기 구문 작성

actor Flight {
    let company = "Luft Hansa"
    var availableSeats = ["1A", "1B", "1C"]
    func getAvailableSeats() -> [String] {
        return availableSeats
    }
    func bookSeat() -> String {
        return availableSeats.removeFirst()
    }
}

액터로 선언한 데이터

private func testFlightProblem2() {
      let flight = Flight()
      let queue1 = DispatchQueue(label: "queue1")
      let queue2 = DispatchQueue(label: "queue2")

      queue1.async {            
          Task {
              let bookedSeat = await flight.bookSeat()
              print("Booked seat is \(bookedSeat)")
          }
      }
      queue2.async {
          Task {
              let availableSeats = await flight.getAvailableSeats()
              print("Available Seats \(availableSeats)")
          }
      }
  }

Task, async await를 통해 비동기 구문 블럭 사용
```
Available Seats ["1A", "1B", "1C"]
Booked seat is 1A
```
위 상황에서는 queue2의 블럭이 먼저 실행되었음

Main Actor

private func testFlightProblem3() {
        let flight = Flight()
        let queue1 = DispatchQueue(label: "queue1")
        let queue2 = DispatchQueue(label: "queue2")

        queue1.async {            
            Task { [weak self] in
                let bookedSeat = await flight.bookSeat()
                print("Booked seat is \(bookedSeat)")
                self?.updateLabel(seat: bookedSeat)
            }
        }
        queue2.async {
            Task {
                let availableSeats = await flight.getAvailableSeats()
                print("Available Seats \(availableSeats)")
            }
        }
    }

Task의 비동기 구문은 현재 메인 스레드에서 실행되고 있지 않지만, 조회한 데이터를 UI로 갱신해야 하는 상황
```
@MainActor
  private func updateLabel(seat: String) {
      queueOneLable.text = seat
  }
```
백그라운드 스레드에서 실행된 함수라 할지라도 @MainActor을 따르는 함수이기 때문에 해당 태스크는 디스패치 메인 큐에서 실행, 즉 UIKit과 연결된 메인 스레드에서 실행되는 게 확실하게 보장

[UIKit] Concurrency: QnA

Tue, 27 Dec 2022 09:31:10 GMT

Interview Questions on Concurrency, GCD, Operation Queue | Swift (Mastering Concurrency in iOS - 6)

Concurrency: QnA

Sync vs Async

동기적 → 현재 스레드를 블럭: 특정 코드를 실행한다면 현재 스레드 실행 중 코드가 실행 완료될 때까지 블럭
비동기적 → 현재 스레드를 블럭하지 않음: 특정 코드를 실행한다면 별도로 실행 OK

Serial Queue vs Concurrent Queue

시리얼: 한 번에 한 태스크
컨커런트: 한 번에 여러 개의 태스크 → 컨커런트 큐라 할지라도 FIFO라는 자료구조의 특성은 모두 보장

Serial vs Sync & Concurrent vs Asnyc

시리얼/컨커런트 큐 → 현재 디스패치되고 있는 목적 큐에 영향을 미침. 어떻게 실행이 순차적으로 또는 동시적으로 진행될 것인지만
동기/비동기 → 해당 스레드로부터 디스패치되고 있는 현재 스레드에 영향을 미침.

    private func testProblem1() {
        let queue = DispatchQueue(label: "printNumbers")
        var numbers: String = ""
        for i in 50...55 {
            numbers += "\(i) "
        }
        print(numbers)
        queue.async {
            var numbers: String = ""
            for i in 10...15 {
                numbers += "\(i) "
            }
            print(numbers)
        }
        queue.async {
            var numbers: String = ""
            for i in 0...5 {
                numbers += "\(i) "
            }
            print(numbers)
        }
        for i in 30...35 {
            numbers += "\(i) "
        }
        print(numbers)
    }

큐는 컨커런트하지 않으므로 디폴트로 시리얼 큐로 구현

두 개의 비동기 실행 블럭이 존재

50 51 52 53 54 55 
30 31 32 33 34 35 
10 11 12 13 14 15 
0 1 2 3 4 5

비동기라 할지라도 시리얼 큐이기 때문에 10...15 프린트 블럭이 0...5보다 언제나 더 먼저 실행될 것은 확실하게 보장
30...35 프린트 블럭은 비동기 코드 블럭과 별개로 실행되기 때문에 언제 실행될 것인지 전후 상황을 예측 불가능

    private func testProblem2() {
        let queue = DispatchQueue(label: "printNumbers", attributes: .concurrent)
        var numbers: String = ""
        for i in 50...55 {
            numbers += "\(i) "
        }
        print(numbers)
        queue.async {
            var numbers: String = ""
            for i in 10...15 {
                numbers += "\(i) "
            }
            print(numbers)
        }
        queue.async {
            var numbers: String = ""
            for i in 0...5 {
                numbers += "\(i) "
            }
            print(numbers)
        }
        numbers = ""
        for i in 30...35 {
            numbers += "\(i) "
        }
        print(numbers)
    }

컨커런트한 큐로 구현
시리얼 큐가 아니기 때문에 해당 큐 내부에서 실행된 두 개의 비동기 구문 순서는 보장 불가능
```
50 51 52 53 54 55 
30 31 32 33 34 35 
0 1 2 3 4 5 
10 11 12 13 14 15
```
일반 (메인 스레드)에서 실행된 50...55, 30...35 블럭은 순서대로 실행 예측 가능
비동기 구문의 두 가지 블럭은 30...35 구문 이전, 이후에 나올 지 예측 불가능
비동기 큐에 들어간 두 가지 태스크(10...15, 0...5)의 순서 또한 컨커런트한 큐인 까닭에 예측 불가능

QoS - Where to use

단일한 파라미터에 의해 조정 가능한 퀄리티
유저 인터렉티브, 유저 이닛, 유틸리티, 백그라운드 등으로 크게 구별 가능
각각 애니메이션(UI 업데이트에 포함?), 즉각적 결과(문제없는 UX 플로우를 제공하는 데 필요한 데이터?), 오랫 동안 작동하는 태스크(유저가 해당 진행 정도를 알고 있는지?), 유저에게 보이지 않는 태스크(유저가 태스크를 알고 있는지?) 등 특징 존재

Multiple API calls

여러 개의 API 호출을 시도한 뒤 해당 태스트들이 모두 종료되었을 때에만 다음 프로세스로 진행 가능한 방법
디스패치 그룹을 사용: enter / leave 함수 사용
notify 함수를 통해 캐치
컴바인 프레임워크의 zip을 통해서도 동일한 동작을 작동할 수 있지만, 해당 방법은 업스트림의 성공 값만을 다운스트림으로 전달하는 까닭에 API 호출 이후 태스크 실패 상황을 핸들링하는 데 어려움

Race condition

디스패치 배리어 플래그

디스패치 세마포어

private func addItems(item: ItemModel) {
      semaphore.wait()
      if walletBalance >= item.price {
          PurchaseManager.shared.buyItem(item: item, balance: walletBalance) { [weak self] success in
              guard let self = self else { return }
              if success {
                  DispatchQueue.main.async {
                      self.walletBalance -= item.price
                      self.cartBalance += item.price
                      self.semaphore.signal()
                  }
              }
          }
      }
  }

세마포어의 카운터 값을 커스텀 가능함으로써 현재 크리티컬 섹션에 들어갈 수 있는 스레드 개수를 조정할 수 있음. 디스패치 배리어는 세마포어보다 세밀한 조정을 하는 데 어려움

GCD vs Operation Queue

GCD와 오퍼레이션 큐는 사실상 비교 가능한 대상이 아님
GCD는 로우 레벨의 API인 반면 오퍼레이션 큐는 탑 레벨의 추상 클래스
GCD는 상황이 복잡하지 않고 실행의 상태를 고려하지 않아도 될 때 주로 사용. 태스크에 대한 컨트롤이 그렇게 필요하지 않을 때.
오퍼레이션 큐는 오퍼레이션 간의 디펜던시를 조절하거나 클래스 상속을 통한 재사용 등 추후 컨트롤을 요할 때 사용.

Cancel the Task in GCD

디스패치 워크 아이템 → GCD를 사용하면서 해당 아이템을 취소 가능
하지만 워크 아이템 취소는 오퍼레이션을 취소하는 데 제공된 변수, 함수 등과는 별도로 다소 제한적

Async Operation

오퍼레이션을 비동기적으로 실행하는 방법
오퍼레이션을 상속하는 새로운 클래스를 작성하기 → start(), cancel(), isAsynchronous 등 프로퍼티를 새롭게 작성한다면 해당 클래스는 비동기적으로 작동하는 오퍼레이션임

class AsyncOperation: Operation {
    enum State: String {
        case isReady
        case isExecuting
        case isFinished
    }

    var state: State = .isReady {
        willSet(newValue) {
            willChangeValue(forKey: state.rawValue)
            willChangeValue(forKey: newValue.rawValue)
        }
        didSet {
            didChangeValue(forKey: oldValue.rawValue)
            didChangeValue(forKey: state.rawValue)
        }
    }
    override var isAsynchronous: Bool { true }
    override var isExecuting: Bool { state == .isExecuting }
    override var isFinished: Bool {
        if isCancelled && state != .isExecuting { return true }
        return state == .isFinished
    }

    override func start() {
        guard !isCancelled else {
            state = .isFinished
            return
        }
        state = .isExecuting
        main()
    }

    override func cancel() {
        state = .isFinished
    }
}

Dependency between tasks

오퍼레이션 간의 디펜던시를 추가하는 방법
오퍼레이션 큐에 넣는 오퍼레이션 간의 실행 완료 → 실행 시작과 같은 순서를 확실하게 보장하는 방법

Thread safe class

디스패치 배리어, 세마포어 사용
크리티컬 섹션을 정의한 뒤 들어올 수 있는 스레드 컨트롤 가능
액터 사용
구조체는 값 타입이기 때문에 스레드 세이프한 반면, 참조 타입인 클래스는 스레드 세이프하지 않을 수 있다는 것 역시 체크

UI Update in background thread

백그라운드 스레드에서의 UI 업데이트의 가능 여부
UIKit는 메인 스레드와 연결
뷰 드로우 사이클과 연결된 메인 런 루프와 UI 리프레시 이벤트
그래픽 렌더링 또한 메인 스레드에서 해야 하는 이유 → 백그라운드 스레드에서 비동기적으로 실행될 경우 flickering이 발생할 수도 있기 때문

[UIKit] Concurrency: Operations & Operation Queue

Mon, 26 Dec 2022 16:52:10 GMT

Mastering Concurrency in iOS - Part 5 (Operations and Operation Queue)

Concurrency: Operations & Operation Queue

Operation

GCD에 비해 실행 상태, 기능을 조정해야 할 때 사용
서로 다른 태스크 간의 의존성, 재사용되는 함수 블럭의 캡슐화 등을 고려해야 할 때
GCD의 탑 레벨에서 오퍼레이션은 일종의 최고로 추상화된 레이어
단일한 태스크와 연관된 코드 및 데이터를 표현하는 추상화된 단계
block, invocation 오퍼레이션이 존재하지만 스위프트에서 지원하는 오퍼레이션은 전자. 후자는 오브젝트 C에서만 지원
isReady
isExecuting
isCancelled
isFinished
하나의 인스턴스는 단 한 번만 실행 가능

private func testOperations1() {
        let operation: BlockOperation = .init {
            print("First Test")
            // as sync
            sleep(3)
        }
        operation.start()
    }

중간에 슬립을 주었기 때문에 블럭 오퍼레이션이 실행되고 3초 이후에 빠져나옴

  private func testOperations2() {
      let operation: BlockOperation = .init()
      operation.addExecutionBlock {
          print("First block executed")
      }
      operation.addExecutionBlock {
          print("Second block executed")
      }
      operation.addExecutionBlock {
          print("Third block executed")
      }
      operation.start()
      /*
       About to begin operation
       First block executed
       Third block executed
       Second block executed
       Operation executed
       */
      // as async
  }

* 하나의 블럭 오퍼레이션에 익스큐션 블럭을 추가해서 시작
* 비동기적으로 실행되는 블럭
```swift
    private func testOperations3() {
        let operation: BlockOperation = .init()
        operation.completionBlock = {
            print("Execution completed")
        }

        operation.addExecutionBlock {
            print("First block executed")
        }
        operation.addExecutionBlock {
            print("Second block executed")
        }
        operation.addExecutionBlock {
            print("Third block executed")
        }
        DispatchQueue.global().async {
            operation.start()
            print("Did this run main thread: \(Thread.isMainThread)")
        }
        /*
         About to begin operation
         Operation executed
         First block executed
         Third block executed
         Second block executed
         Execution completed
         Did this run main thread: false
         */
        // even if in global async, should be serialized following the concept of operation execution blocks.
    }

글로벌 큐에서 오퍼레이션이 비동기적으로 실행될 때, 블럭이 추가된 순서대로의 실행 순서를 보장하고 싶을 때에는 다른 방법을 모색해야 함

    private func testOperationQueues1() {
        let operationQueue: OperationQueue = .init()
        // operationQueue.maxConcurrentOperationCount = 1
        // with this property, serialization can be done
        let operation1: BlockOperation = .init()
        operation1.addExecutionBlock {
            print("Operation 1 being executed")
            for i in 1...10 {
                print(i)
            }
        }
        operation1.completionBlock = {
            print("Operation 1 executed")
            // completion block timing issue
        }

        let operation2: BlockOperation = .init()
        operation2.addExecutionBlock {
            print("Operation 2 being executed")
            for i in 11...20 {
                print(i)
            }
        }
        operation2.completionBlock = {
            print("Operation 2 executed")
        }

        operation2.addDependency(operation1)
        // operation2 -> operation1. i.e. operation2 should wait for operation1 to be completed

        operationQueue.addOperation(operation1)
        operationQueue.addOperation(operation2)
        // by default -> operation queue's task should be done concurrently
    }

하나의 오퍼레이션 큐를 만든 뒤 해당 큐에 여러 개의 오퍼레이션을 넣는 것
디폴트 값으로는 큐에 들어간 오퍼레이션 블럭 실행은 또한 컨커런트하게 실행
오퍼레이션 1의 태스크를 2보다 '먼저' 실행해야 할 때에는 다음과 같은 방법 → 오퍼레이션 1을 먼저 작성했다면, maxConcurrentOperationCount 값을 설정함으로써 컨커런트하게 실행 가능한 오퍼레이션 개수를 제한해버리는 것. → 일반적으로는 오퍼레이션 간의 디펜던시를 통해 실행 순서를 보장
```
private func printOneToTen() {
      DispatchQueue.global().async {
          for i in 1...10 {
              print(i)
          }
      }
  }

  private func printElevenToTwenty() {
      DispatchQueue.global().async {
          for i in 11...20 {
              print(i)
          }
      }
  }
```

다음과 같은 프린트 함수를 각각 오퍼레이션 1, 2에서 실행한다고 가정해보자.

private func testOperationQueues2() {
      let operationQueue: OperationQueue = .init()
      let operation1: BlockOperation = .init(block: printOneToTen)
      let operation2: BlockOperation = .init(block: printElevenToTwenty)
      operation2.addDependency(operation1)
      operationQueue.addOperation(operation1)
      operationQueue.addOperation(operation2)
  }

디펜던시를 추가한다 할지라도 순차적 태스크 실행이 보장되지 않을 수 있음

개인적으로 실행했을 때에는 언제나 디펜던시에 따라 태스크가 실행이 되었는데, 강의 영상에서는 프린트되는 숫자를 보면 컨커런트했다...

class AsyncOperation: Operation {
  enum State: String {
      case isReady
      case isExecuting
      case isFinished
  }

  var state: State = .isReady {
      willSet(newValue) {
          willChangeValue(forKey: state.rawValue)
          willChangeValue(forKey: newValue.rawValue)
      }
      didSet {
          didChangeValue(forKey: oldValue.rawValue)
          didChangeValue(forKey: state.rawValue)
      }
  }
  override var isAsynchronous: Bool { true }
  override var isExecuting: Bool { state == .isExecuting }
  override var isFinished: Bool {
      if isCancelled && state != .isExecuting { return true }
      return state == .isFinished
  }

  override func start() {
      guard !isCancelled else {
          state = .isFinished
          return
      }
      state = .isExecuting
      main()
  }

  override func cancel() {
      state = .isFinished
  }
}

* 커스텀 오퍼레이션 클래스를 구현해 비동기 태스크를 수행
* KVO 패턴을 따라 `willSet`, `didSet`을 통해 해당 값의 변화를 관찰
* 언제나 비동기적인 클래스
* `start()` 함수를 오버라이드해서 현재 실행 중인 상태로 변경한 뒤 메인 함수를 실행
```swift
class PrintNumbersOperation: AsyncOperation {
    var range: Range
    init(range: Range) {
        self.range = range
    }

    override func main() {
        DispatchQueue.global().async { [weak self] in
            guard let self = self else { return }
            for i in self.range {
                print(i)
            }
            self.state = .isFinished
        }
    }
}

위의 비동기 커스텀 오퍼레이션 클래스를 상속받는 프린트 오퍼레이션의 메인 함수는 글로벌 큐에서 이니셜라이즈 당시 파라미터로 입력받은 정수 구간을 출력한 뒤 종료되는 구조

private func testOperationQueues3() {
      let operationQueue: OperationQueue = .init()
      let operation1: PrintNumbersOperation = .init(range: Range(0...25))
      let operation2: PrintNumbersOperation = .init(range: Range(26...50))
      operation2.addDependency(operation1)
      operationQueue.addOperation(operation1)
      operationQueue.addOperation(operation2)
      // serialized when async, using dependency
  }

커스텀 비동기 오퍼레이션 클래스를 사용한 위의 오퍼레이션 큐는 언제나 디펜던시에 따라서 실행되는 게 보장

[UIKit] Concurrency: Dispatch Barrier & Semaphore & Work Item Flags

Mon, 26 Dec 2022 15:56:36 GMT

Mastering Concurrency in iOS - Part 4 (Dispatch Barrier, Semaphore, Work Item Flags)

Concurrency: Dispatch Barrier & Semaphore & Work Item Flags

DispatchWorkItemFlags

워크 아이템을 모아놓은 집합
플래그: 여섯 개의 플래그를 통해 QoS 조정, 이중 배리어가 컨커런시와 관련성이 높음
barrier: 레이스 컨디션을 피하거나 태스크 타이밍을 컨트롤하고자 할 때 사용 가능한 플래그
컨커런트 큐에 특정한 워크 아이템이 들어갔을 때 일종의 배리어 역할을 하도록 하는 플래그

@objc private func didTapCombo() {
        for item in items {
            self.purchaseQueue.async(flags: .barrier) { [weak self] in
                guard let self = self else { return }
                self.addItems(item: item)
            }
        }
    }

    private func addItems(item: ItemModel) {
        if walletBalance >= item.price {
            PurchaseManager.shared.buyItem(item: item, balance: walletBalance) { [weak self] success in
                guard let self = self else { return }
                if success {
                    DispatchQueue.main.async {
                        self.walletBalance -= item.price
                        self.cartBalance += item.price
                    }
                }
            }
        }
    }

레이스 컨디션을 해결하기 위해 커스텀 컨커런트 큐에 barriers 플래그를 설정한 채 비동기 구문을 작성하면, 내부 태스크를 순차적으로 보장할 수 있기 때문에 데이터 안전성을 보장할 수 있음

Dispatch Semaphore

디스패치 배리어를 통해 해결 가능한 레이스 문제를 세마포어로도 해결 가능

Critical Section

공유 리소스에 접근하기 위한 구역
크리티컬 섹션에 멀티 스레드가 동시에 접근하게 되면 데이터 안전성에 해가 될 확률이 높음
배타적 접근을 통해 data inconsistency를 해결 가능 → 세마포어
디스패치 배리어 → 해당 태스크 실행 중 다른 태스크 실행을 막는 배타적 역할
세마포어 → 구현 방식에 따라 몇 개의 스레드를 실행할 것인지 모두 결정 가능. counter 값을 몇 개로 설정하느냐에 따라서 스레드 큐의 가용 개수를 설정 가능
크리티컬 섹션에 존재하는 스레드 개수에 따라서 counter 값이 변경, 해당 크리티컬 섹션으로 들어가기 전 단계에 wait(), signal() 메소드를 통해 스레드의 행동을 컨트롤

    private let semaphore = DispatchSemaphore(value: 1)

커스텀 세마포어를 카운터 개수를 설정한 채로 구현

@objc private func didTapCombo() {
      items.forEach { [weak self] item in
          self?.purchaseQueue.async {
              self?.addItems(item: item)
          }
      }
  }

별도의 배리어 플래그를 설정하지 않은 채로 레이스 문제를 유발할 수 있는 구현 방식으로 여러 개의 비동기 함수를 동시 실행

private func addItems(item: ItemModel) {
      semaphore.wait()
      if walletBalance >= item.price {
          PurchaseManager.shared.buyItem(item: item, balance: walletBalance) { [weak self] success in
              guard let self = self else { return }
              if success {
                  DispatchQueue.main.async {
                      self.walletBalance -= item.price
                      self.cartBalance += item.price
                      self.semaphore.signal()
                  }
              }
          }
      }
  }

wait()를 통해 카운터 값에 맞춰 크리티컬 섹션에 들어갈 수 있는 스레드 개수를 한정, signal()을 통해 들어올 수 있음을 알려줌

[UIKit] Concurrency: Dispatch Group & Dispatch Work Item

Mon, 26 Dec 2022 11:41:42 GMT

Mastering Concurrency in iOS - Part 3 (Dispatch Group, Dispatch Work Item)

Concurrency: Dispatch Group & Dispatch Work Item

Dispatch Group

여러 개의 태스크를 그룹화 가능
여러 개의 태스크가 종료될 때까지 기다릴 수 있음
다른 태스크를 계속 진행할 수 있고, 그룹 내 태스크가 종료될 때 알림을 받을 수 있음
enter(), leave(), wait(), notify()

final class SplashViewController: UIViewController {
    private let spinnerView: UIActivityIndicatorView = {
        let view = UIActivityIndicatorView()
        view.startAnimating()
        return view
    }()
    private var launchDataDispatchGroup = DispatchGroup()
    private var cancellables = Set()

    override func viewDidLoad() {
        super.viewDidLoad()
        setUI()
        DispatchQueue.global().async { [weak self] in
            self?.getAppLaunchData()
        }
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        spinnerView.style = .large
        spinnerView.center = view.center
    }

    private func setUI() {
        title = "SplashView"
        navigationItem.largeTitleDisplayMode = .always
        navigationController?.navigationBar.prefersLargeTitles = true
        view.backgroundColor = .systemBackground
        view.addSubview(spinnerView)
    }

    private func getAppLaunchData() {
        launchDataDispatchGroup.enter()
        NetworkManager
            .download(endPoint: .userPreferences)
            .sink { [weak self] completion in
                self?.launchDataDispatchGroup.leave()
                switch completion {
                case .failure(let error): print(error.localizedDescription)
                case .finished: break
                }
            } receiveValue: { _ in
                print("user preference data has received")
            }
            .store(in: &cancellables)

        launchDataDispatchGroup.enter()
        NetworkManager
            .download(endPoint: .appConfig)
            .sink { [weak self] completion in
                self?.launchDataDispatchGroup.leave()
                switch completion {
                case .failure(let error): print(error.localizedDescription)
                case .finished: break
                }
            } receiveValue: { _ in
                print("app Configuration data has received")
            }
            .store(in: &cancellables)

        let waitResult: DispatchTimeoutResult = launchDataDispatchGroup.wait(timeout: .now() + .seconds(5))
        DispatchQueue.main.async { [weak self] in
            switch waitResult {
            case .success:
                print("API call completed before timeout")
            case .timedOut:
                print("APIs timed out")
            }
            self?.spinnerView.stopAnimating()
            self?.navigateToSignVC()
        }
    }

    private func navigateToSignVC() {
        let vc = SignUpViewController()
        let navVC = UINavigationController(rootViewController: vc)
        let keyWindow = UIApplication.shared.keyWindow
        keyWindow?.rootViewController = navVC
    }
}

launchDataDispatchGroup이라는 디스패치 그룹을 통해 태스크에 들어가고 나오는 과정을 컨트롤 가능
DispatchTimeoutResult를 통해 체크하고자 하는 태스크에 걸리는 시간 내 종료 여부를 직접 확인 가능
notify 프로퍼티를 사용한다면 시간과 관계 없이 해당 태스크가 모두 종료되었음을 알림받을 수 있음

Dispatch Work Item

코드 블록의 캡슐화
디스패치 큐 및 디스패치 그룹 모두 디스패치될 수 있음
실행이 시작되지 않은 시점에도 해당 태스크를 취소할 수 있음
검색 쿼리와 같이 유저의 실시간 인터렉션이 태스크로 직결되는 상황에서 인터렉션이 종료될 때까지 불필요한 태스크가 여러 번 실행될 수 있음 → 최종 결과에 상응하는 태스크를 제외한, 이전에 발생했던 태스크들이 존재한다면 해당 태스크를 중도 취소/사전 취소 가능하다는 뜻
cancel: 실행 이전에 프로퍼티 값이 참이라면 실행되지 않음. 실행 도중 워크 아이템이 취소된다면 cancel은 참을 리턴하지만 실행은 중단되지 않을 것.

static func checkUserNameAvailable(userName: String) -> AnyPublisher {
        return Future { result in
            DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
                let answer = userName == "Pikachu" ? true : false
                result(.success(answer))
            }
        }
        .eraseToAnyPublisher()
    }

간단한 실험을 위해 특정 쿼리 값을 넣었을 때에만 참을 리턴하고, 나머지는 거짓을 리턴하는 함수를 만들자
비동기 데이터를 처리하기 위해, 그리고 네트워킹을 모킹하기 위해 Future 내에서 asyncAfter를 써서 1초 뒤에 해당 값을 리턴한다.

    @objc private func textFieldDidEdit() {
        nameAvailabilityWorkItem?.cancel()
        errorLabel.isHidden = true
        let userName = nameTextField.text ?? ""

        let workItem: DispatchWorkItem = DispatchWorkItem {
            NetworkManager.checkUserNameAvailable(userName: userName)
                .receive(on: DispatchQueue.main)
                .sink { _ in
                } receiveValue: { [weak self] isAvailable in
                    self?.errorLabel.isHidden = isAvailable
                }
                .store(in: &self.cancellables)

        }
        nameAvailabilityWorkItem = workItem
        DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(1), execute: workItem)
    }

특정 텍스트 필드(이름)에 텍스트를 입력할 때마다 API를 통해 텍스트 필드에 입력된 API 쿼리를 실행하는 게 아니라, 타이핑이 끝난 지 1초가 지나서야 비로소 API 쿼리를 실행(디스패치 글로벌 큐에서 asyncAfter를 통해 해당 워크 아이템을 실행하는 타이밍을 1초 후로 조정하는 게 핵심)
지난 시점 생성된 워크 아이템은 cancel을 통해 아직 실행되지 않았다면 취소 가능

위와 같은 쿼리문의 타이밍 조절은 퍼블리셔를 다루는 여러 가지 기법 중 throttle, debounce를 통해 더욱 더 쉽게 조절할 수 있다! 하지만 디스패치 워크 아이템 또한 하나의 방법이 될 수 있다는 것 역시 체크해 놓자

[UIKit] Concurrency: Dispatch Queue & QoS & Attributes

Mon, 26 Dec 2022 09:36:41 GMT

Mastering Concurrency in iOS - Part 2 (Dispatch Queues, Quality of Service, Attributes)

Concurrency: Dispatch Queue & QoS & Attributes

Dispatch Queue

Main Queue

시스템이 생성한 메인 큐
순차적으로 태스크를 할당, 메인 스레드를 사용
다른 큐에서의 메인 스레드 사용은 지양됨 → UIKit이 메인 스레드에 묶여 있는 까닭에 모든 UI 관련 동작은 메인 큐에서 진행되어야 함

Global Cuncurrent Queues

시스템이 생성한 글로벌 큐
동시적으로 태스크를 할당
메인 스레드가 아닌 다른 스레드를 사용
QoS를 통해 우선순위 결정

DispatchQueue.main.async {
    let threadCondition = Thread.isMainThread ? "Execution in Main Thread" : "Execution in Global Thread"
    print("Main Queue: \(threadCondition)")
}

DispatchQueue.global(qos: .background).async {
    let threadCondition = Thread.isMainThread ? "Execution in Main Thread" : "Execution in Global Thread"
    print("Global Queue: \(threadCondition)")
}

글로벌 큐에서의 모든 qos를 적용한다 할지라도 메인 스레드는 오로지 메인 큐에서만 사용 가능

Application Box

NSRunloop → UIKit → 이벤트 대기 → AppDelegate ... → GCD Queue → DB Query...
유저 인터렉션 등 UI 관련 이벤트는 메인 스레드 주관이지만, 해당 데이터를 얻기 위한 DB 조회 등 모든 사건을 메인 스레드에서 처리할 경우 불필요한 리소스 낭비
글로벌 큐에서 제공하는 멀티 스레딩을 통해 리소스의 효율적 사용 가능
싱글 코어 HW: HW의 코어가 하나라면, 코어 당 한 타임 퀀덤에 할당할 수 있는 큐는 하나라는 뜻. 즉 어떤 큐를 실행해야 할지 결정할 필요가 있음
글로벌 큐에서 실행되는 여러 가지 종류의 태스크는 종류에 따라 우선순위를 설정 가능하기 때문에 어떻게 리소스를 사용할 것인지 결정 가능

QoS

User Interactive: 애니메이션(메인 큐에서의 UI 핸들링과 별도로 애플이 도입한 유저 인터렉티브 Qos는 현재 논쟁적 이슈) - UI 업데이트와 관련 있는지 체크
User Initiated: 직접적인 결과(테이블뷰 스크롤을 통해 다음 데이터를 즉각적으로 얻어와야 하는 시점 등) - 부드러운 UX를 제공하는 데 있어 필요한 데이터인지 체크
Utility: 오랫 동안 유지되는 태스크 - 유저가 해당 진행도를 알고 있는지 체크
Background: 유저에게 보이지 않는 태스크 - 유저가 해당 태스크를 알고 있는지 체크
유저 인터렉티브 - 유저 이닛 - 유틸리티 - 백그라운드 순서대로 우선순위 보장
Default: 유저 이닛과 유틸리티 사이
Unspecified: QoS 정보가 없을 때

DispatchQueue.global(qos: .background).async {
    for i in 100...200 {
        print(i)
    }
}

DispatchQueue.global(qos: .userInteractive).async {
    for i in 0...99 {
        print(i)
    }
}

QoS가 서로 다른 글로벌 큐 간의 실행 순서는 보장할 수 없지만 종료 시점은 예측 가능 → 백그라운드 글로벌 큐의 태스크가 유저 인터렉티브 큐에서 실행한 태스크보다 늦게 종료됨은 보장할 수 있음

Attributes

concurrent: 커스텀 큐를 설정할 때 동시성 여부를 체크 가능
initiallyInactive: 시작 시점에는 액티브하지 않은 상태로 설정 가능
target queue: 커스텀 큐가 실제로 화면 뒤에서 사용하는 큐. 특정 디스패치 큐의 우선순위는 그 큐의 타겟 큐로부터 상속받음. 타겟 큐를 특정하지 않는다면 디폴트로 '디폴트 우선순위 글로벌 큐'가 타겟 큐가 됨

let a = DispatchQueue(label: "A")
let b = DispatchQueue(label: "B", attributes: [.concurrent, .initiallyInactive])
b.setTarget(queue: a)

b.async {
    print("Testing Thread Activation")
}

b.activate()

a.async {
    for i in 0...5 {
        print(i)
    }
}

a.async {
    for i in 6...10 {
        print(i)
    }
}

b.async {
    for i in 11...15 {
        print(i)
    }
}

b.async {
    for i in 16...20 {
        print(i)
    }
}

.initiallyInactive를 어트리뷰트로 설정하지 않고 이후 b 스레드에 타겟을 설정한다면 크래쉬 → 액티브한 상태의 스레드의 타겟 큐는 변경 불가능하기 때문에 비활성화 상태에서 타겟 큐를 설정, 이후 해당 스레드를 활성화해야 함

Auto Release Frequency

inherit: 타겟 큐로부터 상속
workItem: 개별의 오토 릴리즈 풀
never: 개별 오토 릴리즈 풀을 설정하지 않음

Serial Queue Async

var value: Int = 20
let serialQueue = DispatchQueue(label: "com.queue.Serial")

func doAsyncTaskInSerialQueue() {
    for i in 1...3 {
        serialQueue.async {
            if Thread.isMainThread {
                print("task running in main thread")
            } else {
                print("task running in global thread")
            }
            guard
                let imageURL = URL(string: "https://www.nintenderos.com/wp-content/uploads/2020/04/anime-pokemon-pikachu.jpg"),
                let _ = try? Data(contentsOf: imageURL) else { return }
            print("\(i) finished downloading")
        }
    }
}

doAsyncTaskInSerialQueue()

serialQueue.async {
    for i in 0...3 {
        value = i
        print("\(value) in next block")
    }
}

print("last line in playground")

/*
 task running in global thread
 last line in playground
 1 finished downloading
 task running in global thread
 2 finished downloading
 task running in global thread
 3 finished downloading
 0 in next block
 1 in next block
 2 in next block
 3 in next block
 */

디스패치 큐는 기본적으로 순차적으로 잡을 실행하는 시리얼 큐
시리얼 큐로 들어가는 태스크를 비동기적으로 실행한다 할지라도 들어간 '순서'대로 시리얼 큐가 실행

Serial Queue Sync

var value: Int = 20
let serialQueue = DispatchQueue(label: "com.queue.Serial")

func doSyncTaskInSerialQueue() {
    for i in 1...3 {
        serialQueue.sync {
            if Thread.isMainThread {
                print("task running in main thread")
            } else {
                print("task running in global thread")
            }
            guard
                let imageURL = URL(string: "https://www.nintenderos.com/wp-content/uploads/2020/04/anime-pokemon-pikachu.jpg"),
                let _ = try? Data(contentsOf: imageURL) else { return }
            print("\(i) finished downloading")
        }
    }
}

doSyncTaskInSerialQueue()

serialQueue.sync {
    for i in 0...3 {
        value = i
        print("\(value) in next block")
    }
}

print("last line in playground")

/*
 task running in main thread
 1 finished downloading
 task running in main thread
 2 finished downloading
 task running in main thread
 3 finished downloading
 0 in next block
 1 in next block
 2 in next block
 3 in next block
 last line in playground
 */

동기 상황의 스레드는 메인 스레드. 메인 스레드는 메인 큐에서밖에 실행할 수 없으므로 현 시점은 메인 큐
동기 sync 블럭을 통해 실행한 디스패치 큐로 인해 메인 큐에서 실행되는 태스크는 현재 블락된 상황 → 즉 메인 스레드는 유휴 상태(idle)이므로 시스템은 이러한 메인 스레드를 활용하고자 함 → sync 블럭 내부에서 사용되는 스레드가 글로벌이 아니라 메인 스레드가 되는 까닭

Concurrent Queue Async

var value: Int = 20
let concurrentQueue = DispatchQueue(label: "com.queue.Concurrent", attributes: .concurrent)

func doAsyncTaskInConcurrentQueue() {
    for i in 1...3 {
        concurrentQueue.async {
            if Thread.isMainThread {
                print("task running in main thread")
            } else {
                print("task running in global thread")
            }
            guard
                let imageURL = URL(string: "https://www.nintenderos.com/wp-content/uploads/2020/04/anime-pokemon-pikachu.jpg"),
                let _ = try? Data(contentsOf: imageURL) else { return }
            print("\(i) finished downloading")
        }
    }
}

doAsyncTaskInConcurrentQueue()

concurrentQueue.async {
    for i in 0...3 {
        value = i
        print("\(i) in next block")
    }
}

print("last line in playground")

/*
 task running in global thread
 last line in playground
 task running in global thread
 task running in global thread
 0 in next block
 1 in next block
 2 in next block
 3 in next block
 3 finished downloading
 1 finished downloading
 2 finished downloading
 */

컨커런트 큐에서 비동기적으로 실행되는 태스크는 순서를 보장하지 않음

Concurrent Queue Sync

var value: Int = 20
let concurrentQueue = DispatchQueue(label: "com.queue.Concurrent", attributes: .concurrent)

func doSyncTaskInConcurrentQueue() {
    for i in 1...3 {
        concurrentQueue.sync {
            if Thread.isMainThread {
                print("task running in main thread")
            } else {
                print("task running in global thread")
            }
            guard
                let imageURL = URL(string: "https://www.nintenderos.com/wp-content/uploads/2020/04/anime-pokemon-pikachu.jpg"),
                let _ = try? Data(contentsOf: imageURL) else { return }
            print("\(i) finished downloading")
        }
    }
}

doSyncTaskInConcurrentQueue()

concurrentQueue.sync {
    for i in 0...3 {
        value = i
        print("\(i) in next block")
    }
}

print("last line in playground")

/*
 task running in main thread
 1 finished downloading
 task running in main thread
 2 finished downloading
 task running in main thread
 3 finished downloading
 0 in next block
 1 in next block
 2 in next block
 3 in next block
 last line in playground
 */

동기적으로 실행되는 스레드는 메인 스레드에서 실행

[UIKit] Infinite ScrollView

Sun, 25 Dec 2022 17:01:08 GMT

How to Create Infinite Scroll in UITableView )

Swift: Infinite Scroll & Pagination Tableview (Xcode 11, iOS) - 2020

Infinite ScrollView

구현 목표

기존 스크롤 뷰에 등록된 데이터 이상을 스크롤할 경우 서버 데이터 요청 및 테이블 뷰 UI 리로드

구현 태스크

테이블 뷰 UI 구현
깃허브 유저 데이터 API 구현
서버 데이터 요청을 판별하는 로직 구현
서버 데이터 시 스피너 뷰 추가 및 데이터 패치 완료 시 스피너 삭제 로직 구현

핵심 코드

final class InfiniteScrollViewModel {
    let users: CurrentValueSubject<[UserModel], Never> = .init([])
    let isPaging: CurrentValueSubject = .init(false)
    private var currentLastId: Int? = nil
    private let userService = GithubAPIService.shared

    init() {
        fetchUsers(perPage: 30)
    }

    public func fetchUsers(perPage: Int = 10) {
        guard !isPaging.value else { return }
        var userSubscription: AnyCancellable?
        isPaging.send(true)
        userSubscription = userService
            .fetchUsers(perPage: perPage, sinceId: currentLastId)
            .receive(on: DispatchQueue.main)
            .sink(receiveCompletion: NetworkService.handleCompletion(completion:), receiveValue: { [weak self] receivedUsers in
                guard let self = self else { return }
                var currentUsers = self.users.value
                currentUsers.append(contentsOf: receivedUsers)
                self.users.send(currentUsers)
                self.currentLastId = currentUsers.last?.id
                self.isPaging.send(false)
                userSubscription?.cancel()
            })
    }
}

스크롤 뷰 컨트롤러의 데이터와 관련된 뷰 모델
현재 페이지네이션(즉 서버 데이터 요청)이 이루어지고 있는지 isPaging이라는 퍼블리셔를 통해 관리 → 단순한 불리언 변수가 아니라 퍼블리셔로 한 까닭은 해당 값 변화에 따라 뷰 컨트롤러에서 유의미한 UI 변경 이벤트가 발생하기 때문
fetchUsers 함수는 곧 서버에 데이터를 요청하는 함수. 뷰 모델이 이니셜라이즈되는 순간에만 30개의 데이터를 요청하고, 페이지네이션, 즉 유저가 스크롤을 최하단 부로 내려 새로운 데이터를 서버에 요청할 때에는 기본적으로 10개의 데이터만을 요청
컴플리션 핸들러가 아니라 컴바인을 통한 one-shot 퍼블리셔를 통해 API 데이터 요청 함수를 사용
guard를 통해 현 시점에 페이지네이션, 즉 서버 데이터 요청이 진행 중이라면 중복된 데이터를 요청하지 못하도록 제어
currentLastId를 통해 다음에 불러 올 유저 아이디를 점진적으로 추가

API는 싱글턴 패턴으로 구현

private func bind() {
      viewModel
          .users
          .sink { [weak self] _ in
              self?.tableView.reloadData()
          }
          .store(in: &cancellables)
      viewModel
          .isPaging
          .receive(on: DispatchQueue.main)
          .sink { [weak self] isPaging in
              self?.tableView.tableFooterView = isPaging ? self?.createSpinnerFooter() : nil
          }
          .store(in: &cancellables)
  }

뷰 컨트롤러가 뷰 모델의 퍼블리셔를 구독하는 함수
뷰 모델의 데이터가 새롭게 변경될 때마다 테이블 뷰를 리로드함으로써 갱신 자동화 → UI를 그리는 리소스 이슈가 있으므로 데이터 소스를 일반에서 Diffable로 변경하거나 추가된 데이터만큼만 reloadItems 등을 통해 로드할 수 있음
뷰 모델의 isPaging은 유저에 의한 페이지네이션이 발생할 때에만 값이 참이 되고, 데이터를 서버에서 패치해왔다면 다시 거짓이 되는 퍼블리셔
해당 퍼블리셔에 따라 로딩 중이라는 의미를 유저에게 전달해야 함 → 스피너 뷰를 테이블 뷰 최하단 뷰, 즉 푸터 뷰에 추가함으로써 전달 가능

데이터 패치가 마무리되었다면 다시 하단 부를 없앰으로써 (nil 화) 알림

func scrollViewDidScroll(_ scrollView: UIScrollView) {
      let position = scrollView.contentOffset.y
      let footerPadding: CGFloat = 100
      if position > (tableView.contentSize.height - footerPadding - scrollView.frame.size.height) {
          viewModel.fetchUsers()
      }
  }

스크롤 뷰를 상속하는 테이블 뷰(또는 컬렉션 뷰)의 특성 상 델리게이트 함수로 어느 정도의 스크롤이 진행되었는지 감지 가능
contentOffset을 통해 어느 방향으로 얼마큼 스크롤되었는지 확인 가능
유저가 스크롤한 정도가 현재 존재하는 테이블 뷰의 컨텐츠 사이즈에서 푸터 뷰를 제외한 높이보다 크다면, 즉 마지막 컨텐츠를 넘어서 계속해서 스크롤을 하고 있다는 뜻 → 뷰 모델의 퍼블릭 함수인 패치 함수를 사용

소스 코드

import Foundation
import Combine

class NetworkService {
    enum NetworkingError: LocalizedError {
        case badURLResponse(url: URL?)
        case unknown
        var errorDescription: String? {
            switch self {
            case .badURLResponse(url: let url): return "[🔥] Bad Response from URL: \(url?.absoluteString ?? "")"
            case .unknown: return "[⚠️] Unknown error occured"
            }
        }
    }

    static func handleURLResponse(output: URLSession.DataTaskPublisher.Output, url: URL?) throws -> Data {
        guard
            let response = output.response as? HTTPURLResponse,
            response.statusCode >= 200 && response.statusCode < 300 else
        { throw NetworkingError.badURLResponse(url: url) }
        return output.data
    }

    static func download(with url: URL) -> AnyPublisher {
        return URLSession
            .shared
            .dataTaskPublisher(for: url)
            .tryMap({try handleURLResponse(output: $0, url: url)})
            .retry(3)
            .eraseToAnyPublisher()
    }
    static func download(with urlRequest: URLRequest) -> AnyPublisher {
        return URLSession
            .shared
            .dataTaskPublisher(for: urlRequest)
            .tryMap({try handleURLResponse(output: $0, url: urlRequest.url)})
            .retry(3)
            .eraseToAnyPublisher()
    }
    static func handleCompletion(completion: Subscribers.Completion) {
        switch completion {
        case .failure(let error):
            print(error.localizedDescription)
        case .finished: break
        }
    }
}

네트워크를 사용하는 함수가 많기 때문에 해당 함수의 모듈화
static을 통해 곧바로 사용 가능
```
import Foundation
import Combine
```

final class GithubAPIService { static let shared = GithubAPIService() private let baseURLString = "https://api.github.com/users" private let token = "token [YOUR_GITHUB_TOKEN]"

private init() {}

private func getURL(perPage: Int, sinceId: Int?) -> URLRequest? {
    var urlComponents = URLComponents(string: baseURLString)
    let urlQueryItems: [URLQueryItem] = [
        .init(name: "per_page", value: "\(perPage)"),
        .init(name: "since", value: sinceId?.description ?? "")
    ]
    urlComponents?.queryItems = urlQueryItems

    guard let url = urlComponents?.url else { return nil }
    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = "GET"
    urlRequest.setValue(token, forHTTPHeaderField: "Authorization")
    return urlRequest
}

public func fetchUsers(perPage: Int = 30, sinceId: Int? = nil) -> AnyPublisher<[UserModel], Error> {
    guard let url = getURL(perPage: perPage, sinceId: sinceId) else {
        return Fail(error: URLError(.badURL)).eraseToAnyPublisher()
    }
    return NetworkService
        .download(with: url)
        .decode(type: [UserModel].self, decoder: JSONDecoder())
        .eraseToAnyPublisher()
}

}

* 토큰을 통해 인증하지 않는다면 API 이용 가용량이 적기 때문에 헤더에 토큰 값을 실어 인증
* 싱글턴 패턴으로 구현
```swift

import Foundation

struct UserModel: Codable, Identifiable {
    let id: Int
    let name: String
    let avatarURL: String

    enum CodingKeys: String, CodingKey {
        case id
        case name = "login"
        case avatarURL = "avatar_url"
    }
}

아이디, 사진, 이름만을 간략하게 나타내기 위한 Codable을 따르는 구조체
```
import Combine
import Foundation
```

final class InfiniteScrollViewModel { let users: CurrentValueSubject<[UserModel], Never> = .init([]) let isPaging: CurrentValueSubject = .init(false) private var currentLastId: Int? = nil private let userService = GithubAPIService.shared

init() {
    fetchUsers(perPage: 30)
}

public func fetchUsers(perPage: Int = 10) {
    guard !isPaging.value else { return }
    var userSubscription: AnyCancellable?
    isPaging.send(true)
    userSubscription = userService
        .fetchUsers(perPage: perPage, sinceId: currentLastId)
        .receive(on: DispatchQueue.main)
        .sink(receiveCompletion: NetworkService.handleCompletion(completion:), receiveValue: { [weak self] receivedUsers in
            guard let self = self else { return }
            var currentUsers = self.users.value
            currentUsers.append(contentsOf: receivedUsers)
            self.users.send(currentUsers)
            self.currentLastId = currentUsers.last?.id
            self.isPaging.send(false)
            userSubscription?.cancel()
        })
}

}

* 사실 진정한 의미에서의 MVVM 스타일대로라면 (적어도 내가 알고 있는 선상에서는) 인풋/아웃풋을 나누는 게 보다 효율적이겠지만, 구현 속도의 문제상 그렇게 하지는 않았다.
* 인풋을 보자면 유저의 페이지네이션 유무 / 아웃풋을 보자면 페이지네이션 진행 중의 유무 등으로 구분할 수 있을 것이다.
```swift
final class InfiniteScrollViewController: UIViewController {
    private let viewModel = InfiniteScrollViewModel()
    private var cancellables = Set()
    private lazy var tableView: UITableView = {
        let tableView = UITableView()
        tableView.delegate = self
        tableView.dataSource = self
        tableView.register(InfiniteTableViewCell.self, forCellReuseIdentifier: InfiniteTableViewCell.identifier)
        return tableView
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        setUI()
        bind()
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        tableView.frame = view.bounds
    }

    private func setUI() {
        view.backgroundColor = .systemBackground
        title = "Infinite ScrollView"
        navigationItem.largeTitleDisplayMode = .always
        navigationController?.navigationBar.prefersLargeTitles = true
        view.addSubview(tableView)
    }

    private func bind() {
        viewModel
            .users
            .sink { [weak self] _ in
                self?.tableView.reloadData()
            }
            .store(in: &cancellables)
        viewModel
            .isPaging
            .receive(on: DispatchQueue.main)
            .sink { [weak self] isPaging in
                self?.tableView.tableFooterView = isPaging ? self?.createSpinnerFooter() : nil
            }
            .store(in: &cancellables)
    }
}

간단하게 테이블 뷰를 추가한 뷰 컨트롤러

extension InfiniteScrollViewController: UITableViewDelegate {
  func scrollViewDidScroll(_ scrollView: UIScrollView) {
      let position = scrollView.contentOffset.y
      let footerPadding: CGFloat = 100
      if position > (tableView.contentSize.height - footerPadding - scrollView.frame.size.height) {
          viewModel.fetchUsers()
      }
  }
}

스크롤 뷰 델리게이트 함수는 페이지네이션의 핵심 파트

extension InfiniteScrollViewController: UITableViewDataSource {

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return viewModel.users.value.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        guard let cell = tableView.dequeueReusableCell(withIdentifier: InfiniteTableViewCell.identifier, for: indexPath) as? InfiniteTableViewCell else { fatalError() }
        let model = viewModel.users.value[indexPath.row]
        cell.configure(with: model)
        return cell
    }

    private func createSpinnerFooter() -> UIView {
        let footerPadding: CGFloat = 100
        let footer = UIView(frame: .init(x: 0, y: 0, width: view.frame.size.width, height: footerPadding))
        let spinner = UIActivityIndicatorView()
        footer.addSubview(spinner)
        spinner.center = footer.center
        spinner.startAnimating()
        return footer
    }
}

셀을 그리는 데이터 소스 함수
페이지네이션이 진행 중일 때 그 순간의 스피너 뷰를 푸터 뷰로 만들어야 하기 때문에 함수화

Diffable로 변경 가능

final class InfiniteTableViewCell: UITableViewCell {
  static let identifier = "InfiniteTableViewCell"
  private let avatarImageView: UIImageView = {
      let imageView = UIImageView()
      imageView.translatesAutoresizingMaskIntoConstraints = false
      imageView.layer.masksToBounds = true
      imageView.image = UIImage(systemName: "person.circle")
      return imageView
  }()
  private let nameLabel: UILabel = {
      let label = UILabel()
      label.text = "Name"
      label.translatesAutoresizingMaskIntoConstraints = false
      label.textColor = .label
      label.textAlignment = .center
      label.numberOfLines = 0
      return label
  }()
  private let idLabel: UILabel = {
      let label = UILabel()
      label.text = "100"
      label.translatesAutoresizingMaskIntoConstraints = false
      label.textColor = .systemGray
      label.textAlignment = .center
      return label
  }()
  private var imageSubscription: AnyCancellable?

  override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
      super.init(style: style, reuseIdentifier: reuseIdentifier)
      setUI()
  }

  override func layoutSubviews() {
      super.layoutSubviews()
      applyConstraints()
  }

  override func prepareForReuse() {
      super.prepareForReuse()
      nameLabel.text = nil
      idLabel.text = nil
      avatarImageView.image = nil
      avatarImageView.image = UIImage(systemName: "person.circle")
      imageSubscription?.cancel()
  }

  required init?(coder: NSCoder) {
      fatalError("init(coder:) has not been implemented")
  }

  private func setUI() {
      contentView.addSubview(avatarImageView)
      contentView.addSubview(nameLabel)
      contentView.addSubview(idLabel)
  }

  private func applyConstraints() {
      let nameLabelConstraints = [
          nameLabel.leadingAnchor.constraint(equalTo: avatarImageView.trailingAnchor, constant: 10),
          nameLabel.topAnchor.constraint(equalTo: contentView.safeAreaLayoutGuide.topAnchor, constant: 10),
          nameLabel.bottomAnchor.constraint(equalTo: contentView.safeAreaLayoutGuide.bottomAnchor, constant: -10),
          nameLabel.trailingAnchor.constraint(equalTo: idLabel.leadingAnchor, constant: -10)
      ]
      NSLayoutConstraint.activate(nameLabelConstraints)

      let avatarImageViewConstraints = [
          avatarImageView.leadingAnchor.constraint(equalTo: contentView.safeAreaLayoutGuide.leadingAnchor, constant: 10),
          avatarImageView.heightAnchor.constraint(equalToConstant: 30),
          avatarImageView.widthAnchor.constraint(equalToConstant: 30),
          avatarImageView.centerYAnchor.constraint(equalTo: contentView.centerYAnchor)
      ]
      avatarImageView.layer.cornerRadius = avatarImageView.frame.size.width / 2
      NSLayoutConstraint.activate(avatarImageViewConstraints)

      let idLabelConstraints = [
          idLabel.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -10),
          idLabel.leadingAnchor.constraint(equalTo: nameLabel.trailingAnchor, constant: 10),
          idLabel.topAnchor.constraint(equalTo: contentView.safeAreaLayoutGuide.topAnchor, constant: 10),
          idLabel.bottomAnchor.constraint(equalTo: contentView.safeAreaLayoutGuide.bottomAnchor, constant: -10)
      ]
      NSLayoutConstraint.activate(idLabelConstraints)
  }

  func configure(with model: UserModel) {
      idLabel.text = model.id.description
      nameLabel.text = model.name

      guard let url = URL(string: model.avatarURL) else { return }

      imageSubscription = NetworkService
          .download(with: url)
          .compactMap({UIImage(data: $0)})
          .receive(on: DispatchQueue.main)
          .sink(receiveCompletion: NetworkService.handleCompletion(completion:), receiveValue: { [weak self] image in
              self?.avatarImageView.image = image
              self?.imageSubscription?.cancel()
          })
  }
}

퍼블릭 함수로 열려 있는 configure을 통해 받아들인 데이터로 셀 UI를 그리기
contentView에 맞춰 오토 레이아웃을 했기 때문에 해당 아이디 값이 늘어난다면 그에 맞춰 셀이 늘어나는 다이나믹 구조
별개로 아바타 이미지 뷰의 크기는 고정
AnyCancellables을 전역 변수로 가지고 있기 때문에 prepareForReuse에서 불필요한 데이터 다운로드 태스크를 중도 취소 가능

구현 화면

j_aion.log

[Conference] Swift Concurrency Under the Hood

Swift Concurrency Under the Hood

Concurrency

Async Await

Task Groups

[UIKit] Runloop.Main vs DispatchQueue.Main

Runloop.Main vs DispatchQueue.Main

@Published

Runloop.Main vs DispatchQueue.Main

[UIKit] Opaque Type vs Protocol & Associated Type & Generics

Opaque Type vs Protocol & Associated Type & Generics

Generics

Associated Types

Opaque + associatedtype

[Conference] A crash course of async await

A crash course of async await

Concurrency

History

Sync vs Async

Async Await

Task

Cooperative Thread Pool

Error Handling

Complier Check

Async Properties

Asnyc / Await Scenarios

Async let Bindings

Cancellation

Task Groups

Hierarchy

Async Sequences

Actor

[UIKit] UICollectionView: Prefetch

UICollectionView: Prefetch

구현 목표

구현 태스크

핵심 코드

구현 화면

[SwiftUI] ChartStocksClone: Ticker Symbol Sheet UI

ChartStocksClone: Ticker Symbol Sheet UI

구현 목표

구현 태스크

핵심 코드

구현 화면

[RxSwift] GithubSearchClone

GithubSearchClone

구현 목표

구현 태스크

핵심 코드

[RxSwift] AirPortClone: MapKit

AirPortClone: MapKit

구현 목표

구현 태스크

핵심 코드

[RxSwift] AirPortClone: Modal Presentation

AirPortClone: Modal Presentation

구현 목표

구현 태스크

핵심 코드

구현 화면

[RxSwift] AirPortClone: Handling Memory Leak

AirPortClone: Handling Memory Leak

구현 목표

구현 태스크

핵심 코드

[RxSwift] AirPortClone: CoreLocation

AirPortClone: CoreLocation

구현 목표

구현 태스크

핵심 코드

구현 화면

[RxSwift] AirPortClone: UITableView & RxDataSources

AirPortClone: UITableView & RxDataSources

구현 목표

구현 태스크

핵심 코드

구현 화면

[RxSwift] AirPortClone: UITableViewCell & AirportViewModel

AirPortClone: UITableViewCell & AirportViewModel