FramiOS

StringTokenizer 사용해서 문자열의 단어 갯수 구하기

fram — Fri, 8 Mar 2024 17:48:16 +0900

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine()," ");
        System.out.print(st.countTokens());
    }
}

StringTokenizer에는 countTokens()라는 메소드가 있다. 이를 사용해서 문자열에서의 단어 갯수를 카운트 해주면 된다.

이진 탐색 (Binary Search) 시간 복잡도가 왜 logn일까?

fram — Fri, 8 Mar 2024 00:34:01 +0900

    public static int search(int[] nums, int target) {
        int start = 0, end = nums.length - 1;

        while(start <= end) {
            int mid = (start + end) / 2;

            if(nums[mid] == target) {
                return mid;
            }

            if(nums[mid] < target) {
                start = mid + 1;
            } else {
                end = end - 1;
            }
        }

        return -1; // target 없음
    }

이진 탐색은 divide and conquer의 개념을 가지고 있다.

시간 복잡도는 O(logn)이 되는데, 처음에는 탐색해야 할 데이터가 N개라면 N개 모두가 탐색 범위가 된다. 그 이후
다음 탐색에서 탐색 범위는 절반으로 줄어 N/2 가 되고 그 다음 탐색에서 탐색 범위는 또 절반으로 줄어 N/4가 되고 그 다음은 N/8, N/16 이 되게 된다.

즉 탐색해야 하는 횟수가 k 라면 N개의 데이터를 탐색하는 데 N = 2^k가 된다.

k의 값을 구하려면 k = log2(N)이라 할 수 있다.

로그가 약한 사람들을 위한 팁

log2(8) 은 2를 몇 제곱 해야 8이라는 값을 얻을 수 있느냐는 뜻이다. log2(2^3) 이며 이는 3log2(2)로 표현 할 수 있다.

log2(2), log3(3) ... 등은 값이 일이므로 3log2(2) = 3 이 된다.

즉 2^3 = 8 이고 3 = log2(8)이 된다.

위에서 탐색 범위는 2^k = N 이므로 이를 로그로 표현하면 k = log2(N)이라고 할 수 있다!

VIA로 키크론 키 맵핑 하기

fram — Thu, 25 Jan 2024 13:23:07 +0900

https://usevia.app/

VIA

Your keyboard's best friend

usevia.app

별도 프로그램을 다운로드하지 않고 웹 페이지에서 키 맵핑 할 수 있어요. 크롬을 권장한다고 하는데 같은 계열인 웨일에서도 잘 동작합니다!

맵핑할 키를 누른 다음, 설정하길 원하는 키를 눌러주면 됩니다!

매크로를 사용하려면 우선 매크로를 작성해 주어야 합니다. 가장 왼쪽에 MACROS를 눌러주세요.

지정할 매크로 번호를 눌러주고 </> 버튼을 눌러 줍니다.

중괄호를 열어주시고 지정할 키 이름을 입력하면 VIA에서 사용하는 단축어로 변경됩니다.

맥에서 커멘드는 Left Winow 키와 동일하기 때문에 Ctl + C를 지정하려면 KC_LCUI, KC_C 두 개를 지정해 주면 되요. Save 버튼을 반드시 눌러 저장해 줍니다.

다시 KEYMAP 메뉴로 넘어와서 변경할 키를 눌러주세요.

KEYMAP > MACRO에서 M0를 눌러 키를 맵핑해 줍니다. 키가 맵핑되면 바로 다음 키로 넘어가기 때문에 연속해서 누르지 말고 한 번만 눌러주면 됩니다.

복붙용 키로 만들었는데 생각보다 불편한거 같아요 ㅎㅎㅎㅎ

SwiftUI custom TabBar에 More 제거하는 방법

fram — Wed, 3 Jan 2024 19:53:07 +0900

SwiftUI에서 하단 탭바를 구현하고 싶을 때 TabView를 사용할 수 있다. 하단 탭바 뿐만 아니라 캐러셀 스크롤 뷰 (예를 들어 배너)도 TabView를 사용할 수 있다. 탭 아이템이 없는 커스텀 TabView를 구현했을 때 하단에 자동으로 생기는 More을 제거 하고 싶으면 tabViewStyle modifier를 사용하면 된다.

TabView(selection: viewStore.$selectedCategoryID) {
	// 생략
}
.tabViewStyle(.page(indexDisplayMode: .never))

[SwiftUI] NavigationLink

fram — Sat, 30 Dec 2023 20:52:36 +0900

NavigationStack과 NavigationSplitView에서 뷰 이동을 위해 NavigationLink를 사용할 수 있다.

struct Fruit: Identifiable, Hashable {
    var id = UUID()
    let name: String
    let emoji: String
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
    }
}

리스트에 보여주기 위한 기본 데이터 모델을 정의

struct FruitDetailView: View {
    let fruit: Fruit
    
    var body: some View {
        VStack {
            Text(fruit.emoji)
                .font(.largeTitle)
            Text(fruit.name)
        }
    }
}

데이터 모델을 보여주기 위한 View로서 navigation link에 의해 이동되는 화면

NavigationLink(_ title:destination:)

public init<S>(_ title: S, @ViewBuilder destination: () -> Destination) where S : StringProtocol

List의 목록에서 보여줄 title, 이동할 화면은 destination으로 정의해준다.

struct FruitView: View {
    private var fruits = [Fruit(name: "사과", emoji: " "), Fruit(name: "오렌지", emoji: " "), Fruit(name: "바나나", emoji: " ")]
    
    var body: some View {
        NavigationStack {
            List(fruits) { fruit in
                NavigationLink(fruit.name) {
                    FruitDetailView(fruit: fruit)
                }
            }
        }
    }
}

NavigationLink(destination:label:)

                NavigationLink {
                    FruitDetailView(fruit: fruit)
                } label: {
                    VStack {
                        Text(fruit.name)
                        Text(fruit.emoji)
                    }
                }

만약 단순 라벨이 아닌 커스텀 뷰를 리스트 목록으로 지정하고 싶은 경우 label 파라미터를 사용해 준다.

navigationDestination(for:destination:)

func navigationDestination<D, C>(
    for data: D.Type,
    @ViewBuilder destination: @escaping (D) -> C
) -> some View where D : Hashable, C : View

데이터 타입과 데이터 값을 기반으로 navigation link를 사용할 수 있다.

struct FruitView: View {
    
    private var fruits = [Fruit(name: "사과", emoji: " "), Fruit(name: "오렌지", emoji: " "), Fruit(name: "바나나", emoji: " ")]
    
    var body: some View {
        NavigationStack {
            List(fruits) { fruit in
                NavigationLink(fruit.name, value: fruit)
            }
            .navigationDestination(for: Fruit.self) { fruit in
                FruitDetailView(fruit: fruit)
            }
        }
    }
}

NavigationLink에서 지정한 value에서의 값을 navigationDestination(for:destination:)으로 연결해 준다. LazyVStack, LazyHStack, List 등은 child view가 화면에 보여져야 할 때만 view를 렌더링 하므로 navigationDestination을 lazy 내부가 아닌 바깥에 정의해 줘야 한다.

사용자가 NavigationLink를 탭하면 navigationDestination에 의해 상세 화면으로 이동한다.

참고 사이트 및 도서

Routing & Navigation in SwiftUI — the right way

Learn how to create a light & simple routing layer to handle your application’s navigation

blorenzop.medium.com

NavigationLink | Apple Developer Documentation

A view that controls a navigation presentation.

developer.apple.com

[TCA] TCA에서의 비동기 처리

fram — Thu, 21 Dec 2023 10:47:37 +0900

Reduce

// Reduce<State, Action> initializer
  @inlinable
  public init(_ reduce: @escaping (_ state: inout State, _ action: Action) -> Effect<Action>) {
    self.init(internal: reduce)
  }

Reduce는 Effect<Action>을 반환하는 클로져를 가지고 있음
Effect<Action>을 사용해서 상태를 관리
- Reducer 내부에서 State를 변형하고 관리
- Effect를 Application에 피드백 (Side Effect)

-> Reducer 내부에서 Reduce를 가지고 상태를 관리한다. 이때 effect를 일으켜 피드백을 할 수 있는데 이를 side effect라고 한다.

.run

Reduce는 Effect<Action>을 반환해야 한다

  public static func run(
    priority: TaskPriority? = nil,
    operation: @escaping @Sendable (_ send: Send<Action>) async throws -> Void,
    catch handler: (@Sendable (_ error: Error, _ send: Send<Action>) async -> Void)? = nil,
    fileID: StaticString = #fileID,
    line: UInt = #line
  ) -> Self

Effect의 익스텐션에 정의된 static 함수인 run의 반환타입은 Self 즉 Effect
operation으로 비동기 코드를 전달하고 실행

operation: @escaping @Sendable (_ send: Send<Action>) async throws -> Void,

Send<Action>을 사용해서 결과를 피드백 하며 Action 케이스의 연관 값으로 결과를 전달
operation { } 클로저 내부의 작업은 작업을 위한 새로운 스레드에서 처리 (Task), 비동기 작업의 결과는 main 스레드에서 처리 되어야 함(State 반영)

Send

operation: @escaping @Sendable (_ send: Send<Action>) async throws -> Void,

operation { } 클로저 내부에 send는 Send<Action>

public struct Send<Action>: Sendable {
  let send: @MainActor @Sendable (Action) -> Void

  public init(send: @escaping @MainActor @Sendable (Action) -> Void) {
    self.send = send
  }
  // 생략

Send<Action>에는 send 인스턴스를 내부적으로 가지고 있음
send는 MainActor로서 동작
- Effect의 결과를 State에 반영하면 이 state는 UI를 업데이트 하므로 main 스레드에서 일어나야 함
Sendable을 준수하는 타입은 해당 타입의 인스턴스를 스레드 간 안전하게 전달 할 수 있음
- Send 구조체를 사용해서 Action을 호출할 수 있음

      case .alert(.presented(.confirmSave)):
        return .run { [transcript = state.transcript] send in
          await send(.delegate(.saveMeeting(transcript: transcript)))
          await self.dismiss()
        }

(코드 출처 : TCA / episode-code-samples-main / 0249-tca-tour-pt7 )

위 코드에서 await send(.delegate(.saveMeeting(transcript: transcript))는 MainActor 인스턴스인 send가 state의 변형을 메인스레드에서 할 수 있게 해줌
비동기 처리로 얻은 결과 값을 send를 사용해서 액션으로 피드백 하고 main 스레드의 흐름으로 다시 편입시키는 방식

TCA에서 state 값을 직접적으로 변경하지 않고 send를 활용하고 있는데 이는 Swift의 동시성 프로그래밍과 관련이 있다. TCA비동기 처리의 매커니즘 이해가 필요하다.

2023.12.20 - [Swift] - [Swift] 동시성 프로그래밍(async/await, actor, sendable)

MainActor, Sendable에 대한 예시 코드와 동작은 이 글 참고

~~아 task 안에서 값을 변경을 못하니까 effect의 run 함수에 send를 사용해서 action으로 피드백 하는 구나~~

비동기 처리 매커니즘 이해하기

위 비동기 처리에서 Task가 생성할 새로운 스레드에서 새로운 값을 할당하려고 할 때 이 할당 되는 시점은 어느 시점에 이루어질지 확정할 수 없음
외부 변수를 비동기 맥락에서 변형할 수 없음

inout은 파라미터로 전달된 값의 원본 값을 변경할 수 있음
변형 가능성을 가지는 inout 파라미터를 비동기 맥락에서 사용할 수 없음

-> 값의 변형은 main에서 수행되어야 함 -> TCA가 MainActor, Send를 도입한 이유

Task에서 안전하게 사용하려면 변형이 불가능한 형태로 전달되어야 함.
값의 캡처 방식으로 전달

class AsyncTest {
    var foo = ""
    
    func doAsyncBar(
        _ foo: inout String,
        mainCompletion: @escaping @Sendable @MainActor (String) -> Void) async {
            Task { [foo = foo] in
                let taskResult = "Task" + foo
                await mainCompletion(taskResult)
            }
    }
}

값을 캡쳐해서 전달 받고 main으로 피드백 하기 위해 mainCompletion 파라미터 추가
mainCompletion
- mainCompletion은 @MainActor을 사용해서 main 스레드에서의 작업을 보장
- @Sendable로 스레드 안전하게 값을 전달
- Task의 결과를 클로저를 통해 전달 할 수 있음

final class AsyncTest: @unchecked Sendable {
    private var foo: String
    
    init(foo: String = "") {
        self.foo = foo
    }
    
    func doAsyncBar(
        _ foo: inout String,
        mainCompletion: @escaping @Sendable @MainActor (String) -> Void) async {
            Task { [foo = foo] in
                let taskResult = "Task" + foo
                await mainCompletion(taskResult)
            }
    }
    
    func updateUI() async {
        await doAsyncBar(&foo) { result in
            self.foo = result
        }
    }
}

최종형태를 확인해 보면 TCA의 Effect run과 유사한걸 확인할 수 있다.

operation: @escaping @Sendable (_ send: Send<Action>) async throws -> Void,

  let send: @MainActor @Sendable (Action) -> Void
  
  public init(send: @escaping @MainActor @Sendable (Action) -> Void) {
    self.send = send
  }

참고 및 출처

Chapter 6. Swift의 비동기 처리와 TCA에서의 응용 | Built with Notion

이번 장에서는 TCA에서의 비동기 처리를 어떻게 관리하는지 알아보기 전에 Swift Concurrency, 즉 동시성 프로그래밍에 대해 알아보겠습니다. Combine 프레임워크와 달리 동시성 프로그래밍은 Task의 병

axiomatic-fuschia-666.notion.site

https://pixabay.com/ko/photos/%EB%B9%84%EB%88%84-%EC%A7%91%EC%97%90%EC%84%9C-%EB%A7%8C%EB%93%A0-%EB%B9%84%EB%88%84-8429699/

[Swift] 동시성 프로그래밍(async/await, actor, sendable)

fram — Wed, 20 Dec 2023 17:54:26 +0900

동기 & 비동기

synchronous는 작업을 동기적으로 실행. 실행 중인 작업이 끝날 때 까지 다른 작업을 기다림

asynchronous는 비동기로 현재 실행 중인 작업이 있어도 다른 작업을 실행 할 수 있다. 오래 걸리는 작업을 비동기로 처리해서 메인 스레드에서 필요로 하는 작업이 멈추지 않게 한다.

MainActor

UI 관련 작업은 메인 스레드에서 실행되어야 하는데, MainActor는 이를 쉽게 관리할 수 있게 해준다. UI 업데이트와 관련된 작업을 메인 스레드에서 실행하도록 보장한다. 비동기 작업에서 메인 스레드로의 접근을 안전하게 관리하기 때문에 스레드 안정적이며 DispatchQueue.main.async와 같은 코드를 작성할 필요가 없어 간결한 코드를 작성할 수 있다.

struct DefaultProductDetailUseCase: ProductDetailUseCase {
    func fetchProductDetail(idx: Int) async throws -> Product {
        let (data, response) = try await URLSession.shared.data(from: URL(string: "https://dummyjson.com/products/\(idx)")!)
        guard let response = response as? HTTPURLResponse,
              (200..<300).contains(response.statusCode) else {
            throw CustomError.statusCodeError
        }
        
        guard let result = try? JSONDecoder().decode(Product.self, from: data) else {
            throw CustomError.invalidResponse
        }
        
        return result
    }
}

비동기 작업을 수행하는 함수가 있다고 할 때 ViewModel에서 아래와 같이 사용할 수 있다.

class ProductDetailViewModel: ObservableObject {
    var useCase: ProductDetailUseCase?
    
    @Published var product: Product?
    
    init(useCase: ProductDetailUseCase) {
        self.useCase = useCase
    }
    
    func getchProductDetail(idx: Int) {
        Task {
            let product = try await self.useCase?.fetchProductDetail(idx: idx)
            await updateUI(with: product)
        }
    }
    
    @MainActor
    private func updateUI(with product: Product?) async {
        self.product = product
    }
}

MainActor을 사용해서 메인 스레드에서 동작해야 하는 코드를 실행한다. 비동기 작업 후 UI 업데이트 코드를 메인 스레드에서 안전하게 실행할 수 있다.

Async

비동기 처리를 수행하는 함수를 정의하려면 async 키워드를 사용해 준다.

    func fetchProductDetail(idx: Int) async -> Product {
		// 생략
    }

async 코드는 concurrent 컨텍스트에서만 실행 가능하다. Task 혹은 다른 async 함수에서 async 함수를 호출할 수 있다.

에러를 반환할 수 있는 경우 async throws로 정의해 준다.

    func fetchProductDetail(idx: Int) async throws -> Product {
		// 생략
    }

Await

        Task {
            let product = try await self.useCase?.fetchProductDetail(idx: idx)
            await updateUI(with: product)
        }

async 함수를 호출하기 위해서 await 키워드를 사용한다. await으로 마킹된 곳은 potential suspension point(잠재적인 일시 중단 지점)으로 지정된다. 즉 이 함수를 호출한 부분도 대기 상태가 될 수 있다는 것을 의미한다.

여기서 suspension point 의 suspend란 스레드를 block 시키는 것이 아니라 다른 동작을 수행할 수 있도록 컨트롤을 포기하는 것을 의미한다. 스레드에 대한 제어권을 system에게 전달하게 되고, 시스템은 해당 스레드를 사용해 다른 작업을 수행할 수 있다. 이후 시스템은 다른 특정 스레드 제어권을 전달해서 suspension point 이후 코드를 수행할 수 있게 한다.

task

다른 Task와 함께 동시에 실행 할 수 있는 비동기 컨텍스트를 제공한다. SwiftUI에서는 task view modifier를 제공하고 있다.

    @inlinable public func task(priority: TaskPriority = .userInitiated, _ action: @escaping @Sendable () async -> Void) -> some View

task modifier는 아래와 같이 사용한다.

        VStack { 생략 }
        .task {
            do {
                try await vm.getProductDetail(idx: 1)
            } catch {
                print("error!")
            }
        }

getProductDetail(idx:)는 error를 반환 할 수 있는 async throw 이기 때문에 task modifier 내부에서 try catch를 사용한다. 만약 task modifier가 아닌 Button을 눌렀을 때와 같은 동작 이후에 수행되야 한다면 Task.init() 를 사용할 수 있다.

@frozen public struct Task<Success, Failure> : Sendable where Success : Sendable, Failure : Error {
}

initializer는 task modifier와 동일하다.

@discardableResult
public init(priority: TaskPriority? = nil, operation: @escaping @Sendable () async -> Success)

            Button {
                Task {
                    do {
                        try await vm.getProductDetail(idx: 1)
                    } catch {
                        
                    }
                }
            } label: {
                Text("버튼으로 실행 할 경우")
            }

Task로 생성된 작업은 백그라운드 스레드에서 즉시 실행되며 await 키워드로 해당 지점에서 완료된 값이 돌아올 때까지 기다릴 수 있다.

inout paramters

concurrency랑 관련된건 아니지만 자주 나와서 정리하자면, inout은 Swift 내에 정의된 키워드.

함수에 값을 전달할 때 매개변수를 사용하게 되는데 이때 매개 변수의 값을 변경해도 원래 변수 값에 영향을 미치지 않는다. inout을 사용하면 함수의 파라미터 값 변경사항을 원본 변수에 적용할 수 있다.

class ProductDetailViewModel: ObservableObject {
    
    @Published var product: Product?
    
    func removeCurrentProduct() {
        self.removeProductRequest(product: &product)
    }
    
    private func removeProductRequest(product: inout Product?) {
        product = nil
    }
    
    // product를 fetch하는 코드는 제외됨
}

SwiftUI의 View에서 removeCurenProduct를 호출하면 viewModel 내부에 정의된 private 함수인 removeProductRequest를 호출한다. 이때 파라미터로 inout 매개변수를 전달한다. 전달받은 매개변수의 값을 변경하면 viewModel의 원본 변수인 @Published로 정의된 product의 값이 nil로 변경된다.

            Button {
                vm.removeCurrentProduct()
            } label: {
                Text("상품 정보 제거하기")
            }
            .buttonStyle(.borderedProminent)
            
            Text(vm.product?.title ?? "")

View 코드로 원본 product 값의 변경을 확인할 수 있다.

removeProductRequest(product: &product)

매개변수 전달시 &(ampersand)을 사용한다. 이는 매개변수가 inout으로 사용되고 있음을 명시적으로 알려준다.

Isolated Actor

동시성을 안전하게 관리하기 위한 타입
Actor 내의 데이터는 다른 스레드나 컨텍스트에서 접근 할 수 없지만 특정 메서드나 프로퍼티를 isolated로 표시하면 해당 actor의 상태에 접근하고 수정할 수 있음
모든 Actor 타입은 암묵적으로 Sendable을 따른다. actor는 mutable state에 대한 isolation을 보장한다.

Sendable

Sendable 타입을 준수하는 타입은 해당 타입의 인스턴스를 스레드 간 안전하게 전달 할 수 있음
Value Type은 내부적으로 Sendable 프로토콜을 따르므로 스레드의 안전을 보장한다.
Reference Type은 final 클래스 혹은 클래스 내 상수 타입으로 선언하여 Sendable 프로토콜을 사용할 수 있다.

(어디에 사용될 수 있을지는 잘 모르겠다 )

  public static func run(
    priority: TaskPriority? = nil,
    operation: @escaping @Sendable (_ send: Send<Action>) async throws -> Void,
    catch handler: (@Sendable (_ error: Error, _ send: Send<Action>) async -> Void)? = nil,
    fileID: StaticString = #fileID,
    line: UInt = #line
  ) -> Self

TCA에서 비동기 처리 이후 Effect를 반환하기 위해 .run을 사용하는데 이때 operation에 @Sendable이 들어가 있다(TCA하다가 여기까지 왔당 ㅋㅋㅋ ㅠㅠ)

struct SendableLibraryStruct: Sendable {
    var name: String
    var bookCount: Int
}

값 타입인 구조체는 Sendable을 준수해준다.

final class SendableLibraryClass: Sendable {
    let name: String
    let bookCount: Int
    
    init(name: String, bookCount: Int) {
        self.name = name
        self.bookCount = bookCount
    }
}

참조 타입인 class는 final class여야 하고 Sendable을 준수해 준다.

actor SendableTestActor {
    private var libraryStruct = SendableLibraryStruct(name: "", bookCount: 0)
    private var libraryClass = SendableLibraryClass(name: "", bookCount: 0)
    
    func updateDataWithStruct(libraryInfo: SendableLibraryStruct) {
        self.libraryStruct = libraryInfo
    }
    
    func updateDataWithClass(libraryInfo: SendableLibraryClass) {
        self.libraryClass = libraryInfo
    }
    
    func getNameFromClass() async throws -> String {
        try await Task.sleep(until: .now + .seconds(1), clock: .continuous)
        return libraryClass.name
    }
    
}

actor는 동시성 접근을 안전하게 관리한다.
내부의 데이터는 다른 스레드나 실행 컨텍스트에서 직접 접근할 수 없다.
특정 메서드나 프로퍼티를 isolated로 표시하면 해당 actor 상태에 안전하게 접근하고 수정할 수 있다.
데이터의 무결성을 유지와 동시성 문제를 해결할 수 있다.

class SendableTestViewModel: ObservableObject {
    @Published var userName: String = ""
    let testActor = SendableTestActor()
    
    func updateStruct() async {
        let libraryInfo = SendableLibraryStruct(name: "kim", bookCount: 19)
        await testActor.updateDataWithStruct(libraryInfo: libraryInfo)
    }
    
    func updateClass() async {
        let libraryInfo = SendableLibraryClass(name: "lee", bookCount: 20)
        await testActor.updateDataWithClass(libraryInfo: libraryInfo)
    }
    
    @MainActor
    func getName() async {
        do {
            self.userName = try await testActor.getNameFromClass()
        } catch {
            
        }
        
    }
}

ViewModel에 actor인 SendableTestActor를 사용해서 스레드 간에 안전하게 값을 전달 할 수 있다. updateStruct()와 updateClass는 값을 전달 받아 내부 데이터를 안전하게 수정한다.

    func getNameFromClass() async throws -> String {
        try await Task.sleep(until: .now + .seconds(1), clock: .continuous)
        return libraryClass.name
    }

actor인 SendableTestActor을 확인해 보면 내부 데이터 중 이름을 반환하는 비동기 함수가 있다. 이를 viewModel에서 전달받아 사용할 수 있다.

    @MainActor
    func getName() async {
        do {
            self.userName = try await testActor.getNameFromClass()
        } catch {
            
        }
    }

actor을 사용하면 actor의 state에 안전하게 접근하고 수정하며 값을 가져올 수 있기 때문에 데이터의 무결성을 유지하면서 동시성 문제를 해결 할 수 있다.

References

[WWDC21] Use async/await with URLSession을 적용해보자..!

해당 글은 [WWDC21] Use async/await with URLSession 보고 작성했습니다. Swift Concurrency 에 대한 얘기가 몇몇 나왔었다. Swift Concurrency에 대해 간략하게 설명해보자면, 코드를 선형적이고 간결하게 만들고, Nat

dev-mandos.tistory.com

[Swift] async / await & concurrency

Swift 5.5 에서 등장한 비동기와 동시성을 위한 방법을 알아봅시다

sujinnaljin.medium.com

https://www.hackingwithswift.com/sixty/5/10/inout-parameters

[SwiftUI] Sendable

What is the Sendable protocol in Swift? | Swift Concurrency 비동기 환경(async)에서 특정 데이터를 보내도 안전한지 점검하는 프로토콜스레드 안전을 보장하는 액터, 특정 액터를 사용하는 여러 개의 스레드 안

velog.io

[Swift] Sendable

Sendable 문서와 WWDC 22 > Eliminate data races using Swift Concurrency 를 조합해서 재구성한 내용입니다. [1] Sendable = safe to share Sendable 프로토콜은 concurrencey 상황에서 안전하게 공유될 수 있는 타입을 나타냅

eunjin3786.tistory.com

+) ChatGPT

이후 공부할 것

Explore structured concurrency in Swift - WWDC21 - Videos - Apple Developer

When you have code that needs to run at the same time as other code, it's important to choose the right tool for the job. We'll take you...

developer.apple.com

Sendable and @Sendable closures explained with code examples

The Sendable protocol and @Sendable attribute help to eliminate data races and create thread-safety in Swift Concurrency.

www.avanderlee.com

https://pixabay.com/ko/photos/%EC%B9%98%EC%A6%88-%EB%84%A4%EB%8D%9C%EB%9E%80%EB%93%9C-%EC%B9%98%EC%A6%88-%EC%8B%9C%EC%9E%A5-8437668/

iOS 15 fullScreenCover(isPresented:) not working

fram — Mon, 18 Dec 2023 11:47:17 +0900

        .onAppear {
            if [조건식] {
                DispatchQueue.main.async {
                    isShowView = true
                }
            }
        }
        .fullScreenCover(isPresented: $isShowView) {
            ChildView()
        }

iOS 16, iOS 17에서는 잘 동작하는데 iOS 15에서는 DispatchQueue.main 으로 해줘야 fullScreenCover가 정상 동작한다.

구체적인 이유는 아직 잘 모르겠답... ㅠㅠ

[TCA] Overriding Dependencies (feat. Dependency Injection)

fram — Wed, 13 Dec 2023 01:04:51 +0900

TCA를 공부하다 보니 SwiftUI 뿐만 아니라 UIKit에서도 사용할 수 있는 Dependency를 제공하길래 따로 글을 적어야 겠더라구요!

의존성을 관리하기 위한 Swinject, Niddle, Factory 등의 라이브러리가 있는데 TCA의 Depdency도 훌륭하고 사용하기 편리한 의존성 관리를 제공합니다.

공식 문서의 공식 번역은 아래 사이트에서 확인할 수 있어요

Chapter 5. Dependency | Built with Notion

5.1 TCA와 Dependency

axiomatic-fuschia-666.notion.site

공식 문서를 보시려면 이 사이트로 이동하시면 됩니다.

Documentation

pointfreeco.github.io

TCA에서는 DI(Dependency Injection)를 위한 @Dependency 프로퍼티 래퍼와 DependencyKey, DependencyValues를 제공합니다. Environment에서 사용한 EnvironmentKey와 EnvironmentValues와 동일한 형태를 갖고 있는 걸 알 수 있는데, Dependency 또한 같은 구현 방식으로 dependency를 전역에서 사용할 수 있도록 만들어 줍니다.

우선은 전역으로 사용할 의존성을 만들어 주어야 해요!!

Dependency 생성

struct ProductClient {
    typealias Products = [Product]
    var fetch: @Sendable (_ offset: Int, _ limit: Int) async throws -> [Product]
}

그 후 Environment와 동일하게 DepdencyKey를 등록하고 DependencyValues에 등록해 의존성을 접근하고 사용할 수 있도록 해주면 됩니다.

ProductClient는 remote 서버로 부터 product 목록을 가져옵니다. 실제 api를 request하는 코드는 DepdencyKey를 등록할 때 작성해 주면 됩니다.

DependencyKeh 등록

extension ProductClient: DependencyKey {
    static let liveValue = Self { offset, limit in
        let (data, _) = try await URLSession.shared.data(from: URL(string: "[api path 생략]?offset=\(offset)&limit=\(limit)")!)
        return try JSONDecoder().decode(Products.self, from: data)
    }
    
    static var previewValue = ProductClient { offset, limit in
        let products = [
            Product(id: 0, title: "맥북 에어 2022", price: 1000, description: "", images: [""], creationAt: "", updatedAt: "", category: Category(id: 0, name: "", image: "", creationAt: "", updatedAt: "")),
            // 생략..
        ]
        
        return products
    }
}

TCA에서는 DependencyKey를 제공해서 전역으로 사용하기 위한 Depdency를 관리할 수 있어요. 여기서 dependency overriding을 제공합니다.

static var liveValue: Value { get }
static var previewValue: Value { get }
static var testValue: Value { get }

TCA의 DependencyKey 내부를 확인해 보면 liveValue, previewValue, testValue를 제공하고 있어요. 각각 상황에 따라 적절한 dependency를 지정한 후 주입해 줄 수 있습니다.

시뮬레이터나 실제 기기에서는 liveValue를 사용해 dependency를 주입하고, preview에서는 preview에서 UI를 확인 하기 위한 용도로 여러 mock 데이터나 실제 api request 코드 등을 넣을 수도 있어요

PointFree 강의를 보니 실제 기기에서 권한 받아오는 것은 문제가 없지만 프리뷰에서는 정상 동작하지 않아 이를 Dependency를 사용해서 각 상황에 맞게 대응해 주고 있었습니다.

의존성을 약하게 만드는 것이 왜 중요한지는 SwiftUI의 Preview를 생각해보면 쉽게 이해할 수 있습니다. SwiftUI는 Canvas에 SwiftUI의 View를 빌드하기 전 미리 보여줍니다. 시뮬레이터와 앱에서 실행하는 코드들과 달리 Preview는 현재 View에서 시작합니다. View가 외부로 부터 필요로 하는 값이 있다면 Preview에서 initializer나 dependency를 주입하는 방식(for example: Environment)을 사용해 주면 됩니다.

이때 View가 필요로 하는 값 중 UserDefault의 값이 있다면 어떻게 해야 할까요? Preview에서 기기에 저장된 값이 있을까요? Preview 뿐만 아니라 Unit Test시 필요로 하는 값은 어떻게 설정해 주어야 할까요?

실제 작동하는 앱 뿐만 아니라 Preview, Test 코드 등에서 이 dependency를 주입해야 하고 이 의존성을 약하고 유현하게 만드는 것이 중요합니다.

DepdencyValues

extension DependencyValues {
    var productClient: ProductClient {
        get { self[ProductClient.self] }
        set { self[ProductClient.self] = newValue }
    }
}

@Depdency 프로퍼티 래퍼를 사용해서 의존성에 접근하고 사용하기 위해 get, set을 통해 코드를 작성해 주면 됩니다. 이로서 모든 준비가 끝났으니 실제 사용하는 방법을 확인해 봅시다.

MainViewModel

final class MainViewModel: ObservableObject {
    var offset = 0
    var limit = 10
    @Published var products: [Product] = []
    
    @Dependency(\.productClient) var productClient
    
    @MainActor
    func fetchProduct() async {
        self.products = try! await productClient.fetch(offset, limit)
    }
}

MainViewModel은 productClient라는 depdency를 가지고 있고 fetchProduct가 실행되면 이 depdency로 부터 데이터를 fetch 해 옵니다.

MainViewModel이 생성될 때 이 dependency 를 주입해 줄 수 있어요

OnboardingView

struct OnboardingView: View {
    @ObservedObject var viewModel: OnboardingViewModel
    
    var body: some View {
        ZStack {
            Button {
                viewModel.startButtonTapped()
            } label: {
                Text("시작하기")
            }
            .buttonStyle(.borderedProminent)
            if viewModel.isShowMain {
                AMainView(viewModel: withDependencies {
                    $0.productClient = .liveValue
                  } operation: {
                    MainViewModel()
                  })
            }
        }
    }
}

AMainView는 MainViewModel을 필요로 합니다. viewModel을 생성할 때 dependency였던 productClient를 주입해 줘야 합니다. 코드를 자세히 살펴 보면

AMainView(viewModel: withDependencies {
    $0.productClient = .liveValue
  } operation: {
    MainViewModel()
  })

withDependecies를 사용해서 depdency를 지정해 주고 있어요.

static var liveValue: Value { get }
static var previewValue: Value { get }
static var testValue: Value { get }

이때 liveValue는 바로 위에서 DepdencyKey를 구현해 줄 때 적어 주었던 값입니다. liveValue는 무조건 적어 주어야 하는 값이고 실제 동작시 사용할 dependency를 정의해 놓기 때문에 Dependency 주입시 liveValue를 사용했습니다.

그렇다면 preview는 어떻게 해야 할까요? 앱을 실제 실행할 때는 liveValue가 필요하지만 preview에서는 실제 데이터가 필요하지 않을 수 있어요. 예를 들어 로그인 뒤에 조회 할 수 있는 api라면 현재 화면 부터 보여주는 preview의 경우 실제 api로 부터 값을 받아 오기 힘들 수도 있습니다.

#Preview {
    AMainView(viewModel: withDependencies {
        $0.productClient = .previewValue
      } operation: {
        MainViewModel()
      })
}

preview도 withDependencies를 사용해서 Dependency의 값을 주입해 주면 됩니다. 이때는 .previewValue를 사용해서 mock 데이터를 보여주면 됩니다.

왼쪽은 Preview 이고, 오른쪽 사진은 실제 시뮬레이터에서 돌렸을 때 나오는 화면입니다. (아니 누가 api 에 있는 값 리셋해놨나봐... 원래 10개 받아와야 하는데 데이터가 진짜 한개밖에 없다.. 누가 건드려쒀... ㅠㅠㅠ)

TCA는 SwiftUI 아키텍처로 사용되는데, DI를 위한 Dependency는 UIKit에서도 적용 가능합니다!

참고 사이트 및 도서

https://pointfreeco.github.io/swift-dependencies/main/documentation/dependencies/overridingdependencies/

https://pointfreeco.github.io/swift-dependencies/main/documentation/dependencies/designingdependencies/

https://pointfreeco.github.io/swift-dependencies/main/documentation/dependencies/overridingdependencies/#Scoping-dependencies

https://www.pointfree.co/collections/tours/composable-architecture-1-0/ep248-tour-of-the-composable-architecture-1-0-dependencies

https://github.com/pointfreeco/isowords/blob/isowords-deploy-v117/Sources/SettingsFeature/Settings.swift

https://github.com/pointfreeco/isowords/tree/main

https://axiomatic-fuschia-666.notion.site/Chapter-5-Dependency-de90da4e19554625af3ffc005ab13ed9

[SwiftUI/TCA] Binding

fram — Thu, 7 Dec 2023 01:59:14 +0900

	SwiftUI	TCA
장점	- State 의 변경 -> UI에 즉시 반영 - 코드 작성이 간단함	- State 변경 로직 관리 용이 - 복잡한 State와 이에 따른 Side Effect 처리 용이
단점	- State 관리가 복잡해 질수록 State 변화에 따른 side effect를 관리하기 어려움	- 어려운 구현 난이도

TCA Binding

  public func binding<Value>(
    get: @escaping (_ state: ViewState) -> Value,
    send valueToAction: @escaping (_ value: Value) -> ViewAction
  ) -> Binding<Value> {
    ObservedObject(wrappedValue: self)
      .projectedValue[get: .init(rawValue: get), send: .init(rawValue: valueToAction)]
  }

get : State를 바인딩의 값으로 변환하도록 하는 클로저
send : 바인딩의 값을 다시 Store에 피드백 하는 Action으로 변환하는 클로저

SwiftUI에서 ChildView에게 Binding<Value>를 전달할 때가 있는데 위 binding<Value>는 그 때 사용하는 것

Text("쿠폰")
.padding(.leading, 10)
VStack {
    TextField("프로모션 코드를 입력해 주세요.", text: .constant(""))
}
.padding()
.border(.black, width: 1)
.padding(.horizontal, 10)

(text에 Binding<String>으로 상위 State를 전달하게 되는데 이때의 State는 어떻게 관리할 것인가에 관한것)

binding(get:send:) 사용 하는 법

    struct State: Equatable {
        var couponCode = ""
        // 생략
    }

State에 텍스트필드에 바인딩 할 프로퍼티를 정의

    enum Action: Equatable {
        case couponCodeInserted(String)
    }

View에서 텍스트 필드를 통해 텍스트를 입력하면 Store가 아닌 Store 외부에 있는 TextField 내부에서 State를 조정하게 됨

이때의 Action을 정의

        Reduce { state, action in
            switch action {
            case .couponCodeInserted(let code):
                state.couponCode = code
                return .none
            }
        }

reducer에서 Action에 대한 결과로 State의 값을 변경

VStack {
    TextField("프로모션 코드를 입력해 주세요.", 
    text: viewStore.binding(
        get: \.couponCode,
        send: { .couponCodeInserted($0) }
    ))}
.padding()
.border(.black, width: 1)
.padding(.horizontal, 10)

TextField의 Binding<String>으로 넘겨준다. 이때 Store의 binding(get:send:)를 사용
viewStore.binding(get:send:)에서 get에 전달된 객체 바인딩 하여 text에 전달, send에 전달된 Action을 Store에 다시 피드백, 이후 해당 Action에 해당하는 reducer 로직이 실행
get으로 State, send로 Action
이벤트를 단방향 통신으로 바꾸고 State와 사이드 이펙트를 관리할 수 있게 됨

binding(get:send)의 단점

각 서브 뷰에서 State를 관리하는 방식이 아니기 때문에 비즈니스 로직이 더 크고 복잡해 질 수록 많은 바인딩 코드가 작성되며 reducer의 관리가 복잡해 짐.
가독성이 나빠지고 반복되는 코드 작업이 필요하게 됨

@BindingState

@BindingState를 사용하면 SwiftUI의 UI 컨트롤에 바인딩 가능
View에서 해당 필드 값 조정 가능
View에서 해당 필드 값을 변경할 수 없도록 하려면 @BindingState를 붙이지 않아야 함
- SwiftUI에서 Binding은 State를 다른 뷰와 공유하는 개념이기 때문에 Source of Truth 관리가 어려워진다. 따라서 모든 필드에 @BindingState를 사용하는건 권장되지 않음 (캡슐화 손상)
- 컴포넌트에 전달하기 위한 필드에만 사용

    struct State: Equatable {
        @BindingState var isToggled = false
    }

BindableAction protocol

    enum Action: BindableAction, Equatable {
        case binding(BindingAction<State>)
    }

Action enum에 BindableAction 프로토콜 채택
BindingState를 사용한 필드는 이 하나의 Action에 연결됨

struct BindingAction<Root>: CasePathable, Equatable, @unchecked Sendable

하나의 Action case가 여러 BindingState에 대응할 수 있게 하기 위해 제네릭 타입을 가짐
제네릭 타입은 reducer의 State

associatedtype State

bindable 내에는 State 타입을 제네릭으로 받기 위해 associatedtype으로 State가 정의되어 있음(바인딩을 위한 상태 값의 타입은 여러가지가 올 수 있음)

BindingReducer

    var body: some ReducerOf<Self> {
        BindingReducer()

reducer에는 BindingReducer를 사용해서 State 변경을 간단하게 할 수 있음
Binding action이 수신되면 State를 업데이트 해주는 reducer
Store 내부 바인딩 가능한 State(예시 코드에서는isToggled) 필드가 업데이트 되면 BindingReducer()가 업데이트 된 필드 값과 함께 Action 수신 후 Reducer 클로저 내에 도메인 로직 처리하여 State에 결과 반영
State와 Action 사이를 바인딩 하는 역활

Reduce { state, action in

action이 BindableAction을 따르게 됨

static func binding(_ action: BindingAction<State>) -> Self

BindableAction의 위 메서드는 BindingAction을 반환
BindingState로 정의한 State를 지정해주면 됨

            case .binding(\.$isToggled):
                return .none
            case .binding(_):
                return .none

Effect를 반환하는 Reduce 클로저에는 case .bindg(_) 에서 정의해 주며 키패스를 사용해서 접근
.binding(_) 도 적어주어야 함

BindingState 프로퍼티 래퍼의 사용

Toggle("test 입니다.", isOn: viewStore.$isToggled)

._printChanges()

received action:
  ProductDetailFeature.Action.amountControl(.plusButtonTapped)
  ProductDetailFeature.State(
-   productAmount: 1,
+   productAmount: 2,
-   amountControl: AmountControl.State(amount: 1)
+   amountControl: AmountControl.State(amount: 2)
    _isToggled: true
  )

바인딩 프로퍼티는 언더바로 표시됨

View State Binding

Store 외부에 있는 View State를 바인딩하기 위해서 BindingViewState 프로퍼티 래퍼를 사용

struct CartButton: View { }

Child View 혹은 Sub View를 만들면 Binding을 통해서 값을 공유해야 하는 상황이 발생하게 되는데 이때 BindingViewState를 사용할 수 있음

let store: StoreOf<ProductDetailFeature>

하위뷰에 상위 스토어를 정의해 주고 init 시점에 전달 받음

    struct ViewState: Equatable {
        @BindingViewState var productAmount: Int
    }

ViewState를 구조체를 만들고 바인딩이 필요한 값을 정의 해줌

    var body: some View {
        WithViewStore(store, observe: { bindingViewStore in
            ViewState(productAmount: bindingViewStore.$productAmount)
        }) { viewStore in
            ZStack(alignment: .bottomLeading) {
                Image(systemName: "cart")
                    .foregroundStyle(.green)
                    .font(.system(size: 30))
                
                if viewStore.productAmount > 0 {
                    Circle()
                        .frame(width: 20, height: 20)
                        .foregroundStyle(.red)
                        .overlay(
                            Text("\(viewStore.productAmount)")
                                .foregroundStyle(.white)
                                .fontWeight(.heavy)
                        )
                        .offset(x: -5, y: 8)
                }
            }
            .frame(width: 50, height: 50)
        }
    }

상위 State에서 전달 받은 값 중에 하위 뷰에서만 사용할 값을 지정하기 위해서 WithViewStore의 observe 파라미터를 지정해 줌
BindingViewStore을 사용해서 상위 뷰의 모든 값에 접근하는 것이 아닌 필요한 값만 공유할 수 있음
ViewState에서 BindingViewState로 지정한 값과 상위 ViewStore로 부터 전달 받은 State를 바인딩 해줌

CartButton(store: self.store)

상위뷰에서 하위뷰를 사용할 때는 store를 전달해 주면 된다.

Pixabay 로부터 입수된  Tim Mossholder 님의 이미지 입니다.