ActionSheet 를 사용하는데 deprecated 되었다고 confirmationDialog를 사용하라고 합니다. 바로 알아봅시다.

ConfirmationDialog

가장 기본적인 confirmationDialog 입니다. 첫번째 인자로 titleKey가 들어가고 isPresented 에 바인딩값을 연결해준 뒤 action 클로저 안에 우리가 평소에 쓰는 Button을 쭉 나열하면 됩니다.

struct ContentView: View {
    @State var isPresented = false
    
    var body: some View {
        Button(action: {
            isPresented = true
        }) {
            Text("사진 불러오기")
                .padding()
        }
        .confirmationDialog(
            "제목",
            isPresented: $isPresented,
            actions: {
                Button("카메라") {
                    print("카메라 선택")
                }
                Button("라이브러리") {
                    print("라이브러리 선택")
                }
            }
        )
    }
}

기본적으로 Cancel 버튼이 존재하고 제목이나 메세지가 생략이 가능합니다.

메세지 추가

.confirmationDialog(
            "제목",
            isPresented: $isPresented,
            actions: {
                Button("카메라") {
                    print("카메라 선택")
                }
                Button("라이브러리") {
                    print("라이브러리 선택")
                }
            },
            message: {
                Text("불러올 사진 위치를 선택해주세요.")
            }
        )

제목 추가

세번쨰 인자로 존재하는 titleVisibility 를 통하여 설정 가능합니다.

.confirmationDialog(
    "제목",
    isPresented: $isPresented,
    titleVisibility: .visible,
    actions: {
        Button("카메라") {
            print("카메라 선택")
        }
        Button("라이브러리") {
            print("라이브러리 선택")
        }
    },
    message: {
        Text("불러올 사진 위치를 선택해주세요.")
    }
)

ActionSheet.Button의 .destructive

.destructive 의 설정은 Button을 생성할 때 할 수 있습니다.

Button("카메라", role: .destructive) {
    print("카메라 선택")
}

확실히 기존의 ActionSheet 보다 더욱 더 선언형에 맞게 변화된 모습이 보이네요. 사용하기에도 더욱 편한것 같습니다.

extension Bundle {
    var appName: String {
        return infoDictionary?["CFBundleName"] as! String
    }

    var bundleId: String {
        return bundleIdentifier!
    }

    var versionNumber: String {
        return infoDictionary?["CFBundleShortVersionString"] as! String
    }

    var buildNumber: String {
        return infoDictionary?["CFBundleVersion"] as! String
    }
}

사용할 때에는 아래와 같이 사용합니다.

let str = "\(Bundle.main.appName) v \(Bundle.main.versionNumber) (Build \(Bundle.main.buildNumber))"

출처: https://stackoverflow.com/questions/25965239/how-do-i-get-the-app-version-and-build-number-using-swift

1. 왜 SwiftUI의 Alert이 아닌 UIKit의 Alert을 사용하는가?

SwiftUI의 Alert

먼저 SwiftUI에서 제공되는 Alert을 사용하기 위한 필요한 요소에 대해 알아보자.

1. alert이 열려있는지 닫혀있는지에 대한 정보를 담은 Bool 타입의 State 변수를 선언한다.

2. View에 alert을 체이닝 형식으로 선언한 후 아까 선언한 State 변수를 연결한다.

3. View의 alert 클로저에 Action처리를 포함한 Alert(View)을 추가한다.

struct AView: View {
	// 1
    @State var isShowingAlert = false
    
	var body: some View {
    	VStack {
        	Button(action: { 
            	isShowingAlert = true
            }) {
            	Text("show alert")
            }
        }
        .alert(isPresented: $viewModel.showingPayAlert) { 	// 2
            // 3
            Alert(
                    title: Text("알림"),
                    message: Text("수락하시겠습니까?"),
                    primaryButton: .default(Text("확인")) {
                        print("action!")
                    },
                    secondaryButton: .cancel(Text("취소")
            )
        }
    }
}

 SwiftUI에서 제공되는 Alert을 사용하려면 해당 Alert이 열림과 닫힘을 알 수있는 State 변수 하나, View타입 끝에 체이닝 형식으로 alert을 하나하나 달아줘야 한다. 만약 여러개의 화면에 모두 각각 alert이 필요하면 매번 State 변수를 만들고 매번 alert을 달아준 다음 해당 action을 추가해야한다. 물론 최상단의 View에 하나의 alert을 달아놓고 매번 최상단의 alert의 binding 변수를 변경해주거나 하는 방법으로 해결할 수 있지만 최상단의 State값이 변경됨으로써 생기는 사이드이펙트들을 또한 신경써줘야 하는 단점이 있었다. 또한 하나의 View에 여러개의 alert이 필요한 경우 하나의 View 타입에 여러개의 alert을 달아주는 경우 정상적으로 동작하지 않는 경우가 생겨 불필요한 코드들이 추가되기도 한다.

 물론 선언형인 SwiftUI에서 어울리는 방법이긴 하다. 하지만 개인적으로 모든 View에서 매번 저 3가지의 작업을 한다는게 번거롭고 코드의 양도 쓸데없이 커진다는 느낌을 받았다.

SwiftUI에서 UIKit

특정 Action을 처리하는 alert인데 굳이 명령형으로 하지 않고 선언형을 사용 할 필요가 있을까?

아래 코드처럼 UIKit를 사용한 AlertController를 만들어 단지 호출만 하여 간단 명료하게 Alert을 표시할 수 있다.

struct BView: View {
	var body: some View {
    	Button(action: { 
        	AlertController.showAlert(
       			title: "알림",
			message: "승인하시겠습니까?",
              	  	primaryAction: { print("승인") }
            )
        }) {
        	Text("show alert!")
        }
    }
}

아래 코드는 가장 상위의 ViewController를 찾은 후 해당 ViewController에 Alert을 추가하는 코드이다.

UIKit의 UIAlertController를 현재 Scene의 가장 상위의 ViewController를 가져와 추가하는 작업이다.

import Foundation
import UIKit

final class AlertController {
    static func showAlert(
        title: String = "알림",
        message: String?,
        primaryAction: @escaping () -> ()
    ) {
        let alert = UIAlertController(
            title: title,
            message: message,
            preferredStyle: .alert
        )
        alert.addAction(
            .init(
                title: "확인",
                style: .default,
                handler: { _ in
                    primaryAction()
                }
            )
        )
        alert.addAction(
            .init(
                title: "취소",
                style: .cancel
            )
        )
        rootController().present(alert, animated: true)
    }
    
    private static func rootController() -> UIViewController {
        guard let screen = UIApplication.shared.connectedScenes.first as? UIWindowScene else {
            return .init()
        }
        
        guard let root = screen.windows.first?.rootViewController else {
            return .init()
        }
        
        return root
    }
}

고찰

SwiftUI를 사용하다 보면 참 편한기능이 많고 생산성이 엄청 좋고 유지보수, 코드 관리가 편하다는 것을 느낀다. 하지만 무조건 장점만은 있는게 아니기 때문에 UIKit의 장점과 SwiftUI의 장점을 잘 종합적으로 사용해야 한다는 생각이 든다.

import Foundation

/*
 동전 종류 N
 가치의 합 K
 
 K원을 만드는데 필요한 동전 개수의 최솟값은?
 */

let firstInputItems = readLine()!.components(separatedBy: " ").map { Int($0)! }
let kinds = firstInputItems[0]
var sum = firstInputItems[1]
var elements = [Int]()

elements = Range(0 ... kinds - 1)
  .map { _ in Int(readLine()!)! }
  .reversed()

var count = 0

elements
  .forEach { element in
    let value = sum / element
    
    if value > 0 {
      count += value
      sum -= element * value
    }
    
    if sum == 0 {
      return
    }
  }

print(count)

해설

입력값을 받아놓고 큰 값부터 처리하기 위해 reversed()를 사용했고 큰값으로 나눈 몫을 동전의 총 가치에서 빼주는 작업을 sum이 0이 될때 까지 진행합니다.

알고리즘 문제를 풀어보려고 하는데 문제를 풀어도 어떤식으로 제출을 해야 하는지에 대한 글입니다.

1. 문제 풀기 위한 Xcode 세팅

1. 먼저 xcode를 열어 new project를 만듭니다.

2. macOS에서 Commend Line Tool을 선택합니다.

3. main.swift 파일에서 문제를 푸시면 됩니다!

Playground로 하지 않고 Command Line Tool로 하는 이유는 아래를 보면 알 수 있습니다.

2. 입력값을 받는 문제

문제중에 입력값을 받는 문제들이 있습니다. 이 입력값을 받기 위해 일반 Playground를 사용하지 않고 Command Line Tool을 사용합니다.

입력값을 받기 위해서는 readLine()을 호출하면 됩니다.

실행을 하게되면 먼저

1. Hello, World!가 찍힘

2. 해당 콘솔창에 insert!!!를 입력

3. 옵셔널로 insert!!!가 print

가 되는 것을 볼 수 있습니다.

import Foundation

let count = readLine()
let insertPersonTimes = readLine()

var personTimes = insertPersonTimes!.components(separatedBy: " ").map { Int($0)! }

personTimes.sort()
var sum = 0
for i in 0 ..< personTimes.count {
  sum += personTimes[i] * (personTimes.count - i)
}

print(sum)

2개의 입력값을 받는 문제입니다 사실 첫번째의 count는 안받아도 될거 같은데... ㅎㅎ

ios 개발을 하면서 커맨드 라인으로 입력값을 받은 적이 없어 약간 해맸네요...

Xcode Swift로 커맨드 라인 입력값 받기

해설

굳이 이전의 값들을 따로 빼서 합을 구해주지 않고 최종적으로 한 사람이 몇 명에게 시간을 주느냐에 관점으로 접근했습니다.

간단하게 첫번째 사람은 한번, 두번째 사람은 두번 ... 이런식이기 때문에 자신이 걸리는 시간 * (인원수 - 자신의 순번) 으로 처리했습니다.

시간 날때마다 알고리즘 문제를 풀어볼까 합니다! 실무에 중요한 그리디 유형부터 진행할 예정입니다!

var amount = Int(readLine()!)!
var bag = 0

while(amount >= 0) {
    if amount % 5 == 0 {
        bag += amount / 5
        print(bag)
        break
    }
    bag += 1
    amount -= 3

    if 1..<3 ~= amount {
        print(-1)
        break
    }
}

while문을 사용하지 않고서는 도저히 쉽게 해결할 방법이 안떠올라 결국 while문으로 풀게 됬네요.

해설

그냥 최대한 단순하게 5로 나누어 떨어질 때 까지 3을 빼주며 1봉지씩 추가하는 방법입니다. while문 도중 3씩 빼고 있는데 남은 수가 1이나 2가 될 경우 -1을 출력합니다.

Back pressure

Combine은 구독자가 데이터의 흐름을 제어하도록 설계되어 있습니다. 그래서 구독자는 파이프라인에서 처리가 발생하는 시기와 대상도 제어합니다. 구독자가 얼마나 많은 정보를 원하거나 수용할 수 있는지에 대한 정보를 제공함으로써 파이프라인 내에서 처리를 주도한다는 것을 의미합니다. 이러한 요청은 구성된 파이프라인을 통해 전파되며 각 Operator는 차례대로 데이터 요청을 수락하고 연결된 Publisher에게 정보를 요청합니다.
이 것을 백 프레셔 라고 불리는 Combine의 기능이라고 합니다!

파이프라인이 취소되면 해당 파이프라인은 다시 시작되지 않습니다. 취소된 파이프라인 대신 새로운 파이프라인을 만들어야 합니다.

생명주기(Life Cycle)

1. 구독자가 게시자에게 연결되면 구독자의 호출로 시작됩니다. .subscribe(_: Subscriber

2. 게시자는 차례대로 구독을 호출을 확인합니다. receive:subscription: Subscription

3. 구독이 승인된 후 구독자는 값을 요청합니다 request(_: Demand)

4. 게시자가 값이 있다면 값을 보내게 됩니다. 게시자는 요청 한 양보다 더 많은 값을 줄 수 없습니다. receive(_: Input)

5. 구독이 완료된 후 언제든지 구독자는 다음과 같이 구독을 취소할 수 있습니다. .cancel()

6. 게시자는 선택적으로 완료가 되었다는것을 보냅니다. 정상적인 종료일 수도 있고 오류 유형을 알려주는 완료일 수도 있습니다. 취소된 파이프라인은 완료를 보내지 않습니다. receive(completion:)

Publisher(게시자)

• 요청 시 데이터를 제공해줌
• 구독이 없는 경우 Publisher는 데이터를 제공하지 않음
• 두 가지 유형을 제공함(Outpt Type, Failure Type)

Subscriber(구독자)

• 구독자는 데이터를 요청하고 Publisher가 제공한 데이터(및 오류)를 처리해야 함
• 입력에 대한 유형과 실패에 대한 유형 두 가지 연관된 유형
• 구독자는 데이터를 요청을 시작하고 수신하는 데이터의 양을 제어함
• Subscriber가 없으면 게시가 아예 되지 않기 때문에 Subscriber는 작업을 주도하는 것으로 생각할 수 있습니다.
  

Operator(연산자)

• 연산자는 Publisher Protocol과 Subscriber Protocol을 모두 채택하는 클래스
• 게시자 구독 및 모든 구독자에게 결과 보내기를 지원
• 게시자가 데이터를 제공하고 구독자가 요청한 데이터를 처리, 반응 및 변환하기 위해 체인을 만들 수 있음
  

연산자는 값 또는 유형을 변환하는데 사용되며 스트림을 분할 또는 복제하거나 스트림을 병합할 수도 있습니다. 그리고 항상 (출력/실패) 유형의 조합으로 정렬되어야 합니다. 만약 유형이 올바르지 않으면 컴파일러에서 오류가 발생합니다!

아래는 간단한 Combine 파이프라인 입니다.

let _ = Just(5)                     // 1
    .map { value -> String in     // 2
        return "a string"
    }
    .sink { receivedValue in      // 3
        print("The end result was \(receivedValue)")
    }

1) Just 파이프라인은 정의되어있는 값으로 응답하는 게시자입니다. 이미 정의되어있는 값이기 때문에 실패 유형이 없죠? 그래서 Error 유형은 NEVER가 됩니다.
2) map을 통해 기존의 값을 기반으로 한 새로운 유형의 값을 반환할 수 있습니다. 예제에서는 기존 값을 무시하고 새로운 String 값을 반환합니다.
3) sink 구독자로 인해 파이프라인이 종료됩니다.

파이프라인은 출력 유형과 실패 유형 두 가지에 의해 연결된 일련의 작업입니다. 파이프라인을 생성할 때 최종 목표를 달성하기 위해 데이터, 유형(스트림의 성공 여부 등)을 변환하는 데 연산자를 사용하게 됩니다. 여기서 말하는 최종 목표는 대부분 사용자 인터페이스 요소를 변화시키는 작업이겠죠? 그렇기에 이러한 변환을 돕기 위한 게 바로 Combine의 연산자입니다.

Combine의 대표 연산자 tryMap

Combine의 연산자를 보다 보면 try###라는 이름의 연산자들이 있습니다. 모두 기존의 함수와 비슷한 동작을 하지만 실패 유형을 가지고 있어 실패 유형에 대한 처리를 도와줍니다. map은 위의 예제에서처럼 String만을 반환하지만 tryMap의 경우 유형을 제공하는 게시자를 <String, Never>을 사용하는 구독자로 끝납니다. 간단하게 throw를 해야 한다면 try가 붙은 연산자를 사용하면 됩니다.

let _ = Just(5) 
    .map { value -> String in 
        switch value {
        case _ where value < 1:
            return "none"
        case _ where value == 1:
            return "one"
        case _ where value == 2:
            return "couple"
        case _ where value == 3:
            return "few"
        case _ where value > 8:
            return "many"
        default:
            return "some"
        }
    }
    .sink { receivedValue in 
        print("The end result was \(receivedValue)")
    }

• Just<Int, Never> 유형의 조합을 만들었고 정의된 단일 값을 제공합니다.
• .map() 함수를 통해 Int를 받아 String으로 반환합니다. 실패 유형인 Never는 변경되지 않으므로 통과됩니다.
• sink를 통해 <String, Never> 조합을 수신합니다.