aloe 기술블로그

Delegate Pattern, Closure 데이터 전달 방식 정리 ("Any"와AnyObject 까지)

개발자 aloe — Thu, 15 May 2025 16:36:05 +0900

많이 들 어려우셨죵 최대한 쉽게 설명해서 깊은 내용까지 한번 들어가보려고 합니다!

델리게이트 패턴(Delegate Pattern)을 알아보자

잠깐 그전에!!!!!!

1. Any와 AnyObject란?

Any
- "모든 타입" 을 저장할 수 있는 타입
- 값 타입(Struct, Enum), 참조 타입(Class, Closure) 모두 저장 가능
- ex) Int, Double, String, Bool, Struct, Class, Closure 다 담을 수 있음
AnyObject
- "모든 클래스 타입" 만 저장할 수 있는 타입
- 오직 클래스 인스턴스만 가능 (구조체, 열거형, 클로저 ❌)

2. Any & AnyObject의 타입 캐스팅

switch-case 패턴 매칭 (as)

as를 이용해 switch 문 안에서 타입별로 분기 처리 가능

for thing in things {
    switch thing {
    case _ as Int:
        print("Int Type!")
    case _ as String:
        print("String Type!")
    case _ as Human:
        print("Human Class Type!")
    case _ as () -> ():
        print("Closure Type!")
    default:
        print("Unknown")
    }
}

다운캐스팅 (as?, as!)
- as?: 타입 변환 시도, 실패하면 nil
- as!: 타입 변환 강제, 실패 시 런타임 에러
```
var name: Any = "Sodeul"
if let str = name as? String {
    print(str.count) // 성공하면 사용 가능
}
```

[심화] Any, AnyObject가 "런타임 시점에 타입이 결정된다"

Swift는 컴파일 시점에 타입을 엄격히 체크하는 언어야.

하지만 Any나 AnyObject로 선언하면, 어떤 타입이 들어올지 컴파일러가 미리 알 수 없어.

즉, "컴파일할 때 타입을 정확히 모른다" → "런타임(앱 실행 중) 때 실제 타입을 확인하고 처리한다" 는 뜻

let value: Any = "Hello"

value.count // 컴파일 에러! (Any 타입은 count를 모름)

여기서 value는 컴파일할 때 그냥 Any야.
그런데 실제 앱이 실행될 때, String이란 걸 알게 돼.
그래서 as?나 as!로 런타임에 타입을 확인해서 사용해야 함

if let stringValue = value as? String {
    print(stringValue.count) // 런타임에 String임을 확인하고 count 사용
}

즉, Any나 AnyObject를 쓸 때는 런타임 타입 확인이 필수야.

(안 하면 크래시가 터지거나, 타입 추론이 안 돼서 메서드 호출도 못함.)

즉 정리를 다시 하면

Any = "진짜 모든 타입 가능"
AnyObject = "오직 클래스 인스턴스만 가능"
둘 다 컴파일 시점에는 정확한 타입을 몰라서 런타임 타입 확인이 필요하다!

자 그러면 본론으로 돌아와서

자자 델리게이트 패턴을 쉽게 알아봅시다

1. 델리게이트 패턴(Delegate Pattern) 이란?

Delegate는 어떤 객체가 "자신의 일을 다른 객체에 위임"하는 디자인 패턴이야.

A 객체가 어떤 행동을 하고 싶지만, "직접" 하지 않고 B 객체에게 "너 대신 해줘"라고 맡기는 구조
대신, B 객체가 어떤 메서드를 구현했는지는 보장해야 하니까 protocol(프로토콜)을 이용해서 "너는 이 함수를 꼭 구현해야 해"라고 규칙을 정해.

정리:

A는 "Delegate 프로토콜"만 알고 있고, B는 그 프로토콜을 준수하면서 대신 행동해주는 거야.

우리는 순서를 좀 기억할 필요가 있음

자격증 만들기 (보통 일을 위임을 시키는 당사자 쪽에서 발급 한다고 생각)
1. 너가 대한민국 변호사라면 해당 자격증을 채택해야해
2. 자격증 안에는 판례 파악하기, 소송 절차 이해하기, 민사소송, 형사소송관련 법률적 근거 알고있기 등등
자격증 채택하기 (나는 변호사야 자격증을 채택했고 너가 말한 기능을 다 할줄 알아 언제든지 요청해줘!)

// 프로토콜 : 자격증(이 자격증을 가진애들은 다 올 수 있음) - 의존성 주입이라는 개념

protocol DataBindDelegate : AnyObject {
    func dataBind(id : String) // 위임할 일을 정의
}

어 나 대한민국 판사인데 너 변호사 자격증 있냐? 있으면 이것좀 해봐라~~

어 나 정정욱인데 너 요아정 좋아하냐? 토핑좀 추가해봐라?

2. AnyObject를 왜 protocol에 붙이는가?

protocol DataBindDelegate: AnyObject {
    func dataBind(id: String)
}

➡️ 이유는 "weak" 참조를 위해서야!

Delegate는 주로 weak으로 선언해.

weak var delegate: DataBindDelegate?

이유는?

delegate는 순환 참조(Retain Cycle)를 방지하기 위해 약한 참조(weak)로 선언하는 게 "관례"야.
그런데 Swift 규칙상 weak은 클래스 타입(Reference Type)한테만 걸 수 있어.
(Struct나 Enum은 Value Type이라 weak 적용이 불가능)

따라서 "Delegate는 클래스만 할 수 있어야 한다" 라고 제한을 걸기 위해서

protocol 정의할 때 : AnyObject를 붙이는 거야.

✅ 즉, AnyObject를 붙이면, "이 프로토콜을 따르는 타입은 클래스만 가능하다"는 뜻

순환참조 관점에서 나의 위임자가 없을수 있음 + 만약 weak이 아니라면 서로가 서로를 가리키는 상황 발생

코드로 알아보자

발급자 관점 (대리자에게 위임하는 쪽)

// 프로토콜 : 자격증(이 자격증을 가진애들은 다 올 수 있음) 발급 

protocol DataBindDelegate : AnyObject {
    func dataBind(id : String) // 위임할 일을 정의
}

class WelcomeViewController_DelegatePattern: UIViewController {
    
    // MARK: - Property
    
    var id: String?
    weak var delegate : DataBindDelegate? // 프로토콜 타입(자격증) 채택한 애들은 다 올수가 있어
    
    // MARK: - UIComponent
    
    let mainImage: UIImageView = {
        let Image = UIImageView(frame: CGRect(x: 120, y: 60, width: 150, height: 150))
        Image.image = ImageLiterals.login
        return Image
    }()
		.
		.
		.
    
    //MARK: Life Cycle
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor = .white
        addViews()
    }
}
extension WelcomeViewController_DelegatePattern{
    
    @objc
    private func backToLoginButtonDidTap() {
        
        if let id = id {
            delegate?.dataBind(id: id) // delegate 야야 너 델리게이트 이것좀 해봐라~
        }
        
        if self.navigationController == nil {
            self.dismiss(animated: true)
        } else {
            self.navigationController?.popViewController(animated: true)
        }
    }
 
}

대리자 관점 (자격증을 채택해서 관련 기능(업무)를 처리)

//
//  LoginViewController_DelegatePattern.swift
//  Week_02
//
//  Created by 정정욱 on 4/12/25.
//

import UIKit

class LoginViewController_DelegatePattern: UIViewController {
    
    // MARK: - UIComponent
    
    let titleLabel: UILabel = {
        let label = UILabel(frame: CGRect(x: 69, y: 161, width: 236, height: 44))
        label.text = "동네라서 가능한 모든것\\n당근에서 가까운 이웃과 함께해요."
        label.font = UIFont.Pretendard.subhead1()
        label.textColor = .black
        label.textAlignment = .center
        label.numberOfLines = 2
        return label
    }()
    
    let idTextField: UITextField = {
        let textField = UITextField(frame: CGRect(x: 20, y: 276, width: 335, height: 52))
        textField.placeholder = "아이디"
        textField.font = UIFont.Pretendard.subhead4()
        textField.backgroundColor = UIColor.Gray200
        return textField
    }()
    
    let passwordTextField: UITextField = {
        let textField = UITextField(frame: CGRect(x: 20, y: 335, width: 335, height: 52))
        textField.placeholder = "비밀번호"
        textField.font = UIFont.Pretendard.subhead4()
        textField.backgroundColor = UIColor.Gray200
        return textField
    }()
}

//MARK: Delegate

extension LoginViewController_DelegatePattern {
    @objc
    private func loginButtonDidTap() {
        //presentToWelcomeVC()
        pushToWelcomeVC()
    }

    private func pushToWelcomeVC() {
        let welcomeViewController = WelcomeViewController_DelegatePattern()
        welcomeViewController.delegate = self // 1. 어어 너의 대리자는 나야
        welcomeViewController.id = idTextField.text
    
        self.navigationController?.pushViewController(welcomeViewController, animated: true)
    }
}

// 2. 너가 말한 자격증을 채택했고 너가 하라는 기능을 나는 할 수 있어 
extension LoginViewController_DelegatePattern: DataBindDelegate {
    func dataBind(id: String) {
        passwordTextField.text = "\\(id) + 1234 "
    }
}

#Preview{
    LoginViewController_DelegatePattern()
}

3. 의존성 주입(Dependency Injection, DI)과의 관계?

Delegate 패턴은 의존성 주입의 일종이라고 볼 수 있어.

A 객체가 "내 일을 대신할 B 객체"를 외부에서 주입받잖아?
직접 생성하거나 의존하지 않고, 외부에서 주입해서 결합도를 낮춘다는 점에서 DI(Dependency Injection) 개념이 들어가는 거야.

요약하면:

의존성 주입은 "필요한 객체를 외부에서 주입받는 것"
델리게이트 패턴은 "필요한 행동을 대신할 객체를 외부에서 주입받는 것"
델리게이트는 특히 행동(메서드 실행)을 외주화하는 특화된 의존성 주입이야.

한눈에 정리

구분 설명

Delegate 패턴	어떤 행동을 다른 객체에 위임하는 패턴
AnyObject 붙이는 이유	Delegate를 weak로 갖기 위해 (클래스만 허용)
Delegate와 DI 관계	Delegate는 의존성 주입의 한 종류 (외부 주입)
weak var delegate	메모리 누수(Retain Cycle) 방지하려고 약한 참조

아니 그럼 이거 왜쓰는건데?.

Delegate 패턴을 언제 써야 해?

"객체끼리 소통이 필요한데, 직접 참조해서 결합도를 높이고 싶지 않을 때" 사용해.

어떤 A 객체가 특정 상황이 되면 B 객체에게 알려야 하는데
A가 B를 직접 알아버리면 둘이 강하게 엮여서(=결합) 유지보수가 어려워져.
이걸 막으려고 "B가 Delegate 프로토콜을 구현하고", A는 그냥 delegate한테 "약하게(weak) 요청"하는것

즉, "낮은 결합(Loose Coupling)"을 만들고 싶을 때 Delegate 패턴을 쓴다!

실전 예시 (iOS)

1. UITableView, UICollectionView

테이블뷰나 컬렉션뷰를 쓰려면 반드시 UITableViewDelegate, UITableViewDataSource를 구현해야 해.
테이블뷰가 직접 데이터를 가지는 게 아니라, "DataSource가 셀 몇개 있는지 알려줘",
"Delegate가 셀 클릭되면 뭐할지 알려줘" 이렇게 위임하는 구조

tableView.delegate = self
tableView.dataSource = self

테이블뷰는 데이터, 동작을 직접 몰라도 돼. (Delegate가 대신 처리)

2. Custom View 내부 이벤트를 외부로 전달할 때

예를 들어, CustomButton이 있는데,

눌렀을 때 특정 ViewController가 뭘 하게 하고 싶어.

버튼이 뷰컨을 "직접 모르면 좋겠어"
그래서 Delegate 프로토콜 만들어서 버튼이 그냥 "나 클릭됐어!"만 알리고
ViewController가 Delegate를 통해 반응하는 거야.

protocol CustomButtonDelegate: AnyObject {
    func didTapButton()
}

class CustomButton: UIButton {
    weak var delegate: CustomButtonDelegate?

    @objc func buttonTapped() {
        delegate?.didTapButton()
    }
}

버튼은 외부가 뭘 하든 신경 안 쓴다! (낮은 결합)

3. A 뷰컨 → B 뷰컨 데이터 전달

A가 B를 present하거나 push 한 다음,
B에서 사용자 입력을 받아서 다시 A로 "결과를 넘겨줄 때" Delegate를 쓴다.

protocol BViewControllerDelegate: AnyObject {
    func didEnterName(name: String)
}

class BViewController: UIViewController {
    weak var delegate: BViewControllerDelegate?

    func doneButtonTapped() {
        delegate?.didEnterName(name: "정정욱")
    }
}

B는 A를 모르고, 그냥 delegate한테 "입력했다"고 알려주는 것뿐

왜 Delegate를 써야 함?

이유 설명

낮은 결합 (Loose Coupling)	서로 직접 의존하지 않아서 유지보수 편해짐
유연성 (Flexibility)	다른 객체로 쉽게 교체 가능
재사용성 (Reusability)	View나 컴포넌트를 다른 곳에서도 쓸 수 있음
메모리 안전 (Memory Safety)	weak 덕분에 순환 참조(Retain Cycle) 방지 가능

개발하다 델리게이트를 써야 하는 순간

CustomView가 외부 이벤트를 전달해야 할 때
뷰컨끼리 결과 데이터를 주고받을 때 (특히 모달 dismiss할 때)
테이블뷰, 컬렉션뷰 같은 UIKit 컴포넌트를 쓸 때
네트워크 콜백 결과를 외부로 넘기고 싶을 때

Closure 방식의 값 전달 델리게이트와 비슷함

A -> B

A <- B

Closure 같는쪽 (야야 나 너가 주는 이름 없는 함수를 받을 준비가 끝났어)
Closure 보내는쪽 (어어 그래? 그러면 너거 적절하게 함수 실행만 시켜 내가 어떤 코드들을 실행 해야하는지는 내쪽에서 정의 할거야)

Closure 같는쪽

class WelcomeViewController_Closure: UIViewController {
    
    // MARK: - Property
    
    var id: String?
    var loginDataCompletion : ((String) -> Void)? // 1. 함수를 받을 준비
    
    // MARK: - UIComponent
    
    let mainImage: UIImageView = {
        let Image = UIImageView(frame: CGRect(x: 120, y: 60, width: 150, height: 150))
        Image.image = ImageLiterals.login
        return Image
    }()

   .
   .
}

//MARK: Action

extension WelcomeViewController_Closure{
    
    @objc
    private func backToLoginButtonDidTap() {
        
        guard let loginDataCompletion else { return }
        if let id = id {
            loginDataCompletion(id) //  2. 어어 나 해당기능 끝나면 너가 준거 실행 시킨다! : 받는놈이 실행을 한다
            /*
             print() // ()붙으면 함수 실행. {}만 있으면 함수 정의(보내는 쪽) 
             */
        }
        
        if self.navigationController == nil {
            self.dismiss(animated: true)
        } else {
            self.navigationController?.popViewController(animated: true)
        }
    }
    
    private func bindID() {
        self.welcomeLabel.text = "\\(id ?? "")님 \\n반가워요!"
    }
    
    func setLabelText(id: String?) {
        //self.id = id // 요놈은 왜 타입 표출 일어남? String? 로 선언 되어 있기 때문임
        self.welcomeLabel.text = "\\(id ?? "")님 \\n반가워요!"
    }
}

Closure 보내는쪽

//
//  LoginViewController_Closure.swift
//  Week_02
//
//  Created by 정정욱 on 4/12/25.
//

import UIKit

class LoginViewController_Closure: UIViewController {
    
    // MARK: - UIComponent
    
    let passwordTextField: UITextField = {
        let textField = UITextField(frame: CGRect(x: 20, y: 335, width: 335, height: 52))
        textField.placeholder = "비밀번호"
        textField.font = UIFont.Pretendard.subhead4()
        textField.backgroundColor = UIColor.Gray200
        return textField
    }()
    .
    .
    .
    
    //MARK: Life Cycle
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor = .white
        addViews()
    }
}

//MARK: Action

extension LoginViewController_Closure {
    
    // 함수를 미리 정의를 해서 던진다 그럼 실행은 어디서 할까? 받은 쪽에서 한다
    private func pushToWelcomeVC() {
        let welcomeViewController = WelcomeViewController_Closure() // 함수를 받을놈
        welcomeViewController.id = idTextField.text
        
        // 1. 함수를 미리 정의 => 던짐 (적절한 곳에서 실행 부탁해)
        // 클로저 값 캡처 방지 [weak self] 이제는 아시죵?
        welcomeViewController.loginDataCompletion = { [weak self] data in
            print("클로저로 받아온 id가 뭐냐면", data)
            guard let self else { return }
            self.passwordTextField.text = data
        } // 여기 까지 함수 정의
    
        self.navigationController?.pushViewController(welcomeViewController, animated: true)
    }
}

#Preview{
    LoginViewController_Closure()
}

Delegate vs Closure 비교

구분 Delegate Closure

기본 개념	'대리'에게 맡긴다 (프로토콜 기반)	코드 블록(함수)을 변수로 넘긴다
설계 방식	프로토콜(Interface)을 정의하고, 구현하는 객체를 외부에서 주입	함수(Closure)를 외부에서 직접 주입
사용 목적	여러 이벤트를 다뤄야 할 때 (복합적/다수)	특정 1개의 작업만 넘길 때 (간단, 직관적)
관계	1:N (여러 함수)	1:1 (한 개 함수)
코드 길이	길어짐 (프로토콜 선언 + 구현)	짧아짐 (inline 가능)
대표 예시	테이블뷰, 커스텀 뷰 이벤트 전달	버튼 클릭 시 단순 액션, 네트워크 응답 처리

Delegate 사용 예시

여러 동작을 넘기고 싶을 때

protocol ProfileViewDelegate: AnyObject {
    func didTapFollowButton()
    func didTapMessageButton()
}

class ProfileView: UIView {
    weak var delegate: ProfileViewDelegate?

    @objc func followButtonTapped() {
        delegate?.didTapFollowButton()
    }

    @objc func messageButtonTapped() {
        delegate?.didTapMessageButton()
    }
}

"Follow 버튼" / "Message 버튼" 각각 다른 일을 Delegate한테 알림

Closure 사용 예시

딱 한 동작만 넘길 때

class ProfileView: UIView {
    var followButtonAction: (() -> Void)?  // 클로저 변수

    @objc func followButtonTapped() {
        followButtonAction?() // 클로저 실행
    }
}

"Follow 버튼 클릭" 하나만 넘기고 끝낼 때 클로저로 깔끔하게 가능.

아니 그럼 언제 뭘 써야 해?

상황 쓰는 것 이유

버튼 한두개 클릭 처리	Closure	간단하고, inline 처리로 코드 짧음
여러 동작을 하나의 객체에 묶어야 함	Delegate	관리하기 편하고 확장성 좋음
복잡한 라이프사이클 관리 (ex: 화면 이동, 상태 변경)	Delegate	명확하게 역할 분리 가능
네트워크 요청 결과 받기	Closure	결과 하나만 넘기면 되니까 간단하게

❤️ 한 줄 요약

Delegate는 여러 행동을 한 번에 넘길 때,

Closure는 단일 이벤트를 간편하게 넘길 때 쓴다.

마지막 요약

Delegate = "A야, 어떤 상황되면 나 대신 알려줘" (Protocol + 구현)
Closure = "A야, 이 코드 한 조각 받아서 실행해줘" (Function as variable)

API 통신 정리: URLSession, async/await 확실한 이해, 네트워크 셋팅, 및 설계

개발자 aloe — Tue, 13 May 2025 21:13:00 +0900

티스토리가 가독성이 안좋아서 노션 링크로 보시는걸 추천 드립니다.

https://amused-flax-90b.notion.site/API-URLSession-async-await-1ee3310a471480479767e69b7f73f37a?pvs=74

Swift에서 URLSession은 HTTP 통신을 위한 기본 API로, 서버와 데이터를 주고받을 때 사용됩니다. 앱에서 REST API와 통신하거나 파일을 다운로드할 때 자주 사용됩니다.

1. URLSession이란?

URLSession은 Apple에서 제공하는 비동기 네트워킹 API입니다. 주로 다음 용도로 사용됩니다:

HTTP/HTTPS 요청 및 응답
파일 업로드/다운로드
백그라운드 전송

디테일하게 설명하면

Apple에서 제공하는 네트워크 통신 API로, 앱이 서버와 데이터를 주고받을 수 있도록 지원합니다.
Alamofire, Moya 등 서드파티 라이브러리의 기반이 되는 핵심 API입니다.
타임아웃, 캐시 정책, 백그라운드 전송 등 다양한 네트워크 설정을 구성할 수 있습니다.(gwonii.github.io, Velog)

2. 기본 구조

let url = URL(string: "<https://api.example.com/data>")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
    // 응답 처리
}
task.resume()

전체 플로우

import Foundation

// 1. URL 생성 (옵셔널 바인딩으로 안전하게 처리)
guard let url = URL(string: "<https://api.example.com/data>") else {
    print("❌ 유효하지 않은 URL")
    return
}

// 2. URLRequest 객체 생성 및 설정
var request = URLRequest(url: url)
request.httpMethod = "GET"  // or "POST", "PUT", "DELETE"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
// 필요 시 헤더 추가 가능
// request.setValue("Bearer ", forHTTPHeaderField: "Authorization")

// 3. URLSession으로 dataTask 생성
let task = URLSession.shared.dataTask(with: request) { data, response, error in
    
    // 4. 에러 체크
    if let error = error {
        print("❌ 네트워크 에러: \\(error.localizedDescription)")
        return
    }

    // 5. 응답 상태코드 확인
    guard let httpResponse = response as? HTTPURLResponse else {
        print("❌ 유효하지 않은 응답 객체")
        return
    }

    print("  상태코드: \\(httpResponse.statusCode)")

    guard (200...299).contains(httpResponse.statusCode) else {
        print("❌ 서버 응답 오류: \\(httpResponse.statusCode)")
        return
    }

    // 6. 데이터 존재 여부 확인 및 JSON 파싱
    guard let data = data else {
        print("❌ 데이터가 없습니다.")
        return
    }

    do {
        // 7. JSON 파싱 (Dictionary 또는 Array 형태)
        if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
            print("✅ 파싱된 JSON: \\(json)")
        } else {
            print("❌ JSON 형식이 Dictionary가 아닙니다.")
        }
    } catch {
        print("❌ JSON 디코딩 실패: \\(error)")
    }
}

// 8. 네트워크 요청 시작
task.resume()

3. 주요 클래스 구성

클래스/타입 설명

URLSession	네트워크 작업을 관리하는 객체
URLSessionTask	네트워크 요청을 나타냄 (dataTask, uploadTask, downloadTask)
URLRequest	요청 정보 설정 (URL, HTTP 메서드, 헤더, 바디 등)
URLResponse, HTTPURLResponse	응답 정보

URLSessionConfiguration 종류 (네트워크 작업 관리 객테의 종류)

URLSession은 네 가지 세션 구성을 제공합니다:

Shared Session
- 싱글턴 패턴으로 구현되어 간단한 요청에 적합합니다.
- 커스터마이징이 불가능하며, 백그라운드 전송을 지원하지 않습니다.
```
let url = URL(string: "<https://example.com/data>")!
URLSession.shared.dataTask(with: url) { data, response, error in
    // 응답 처리
}.resume()
```

Default Session

Shared Session과 유사하지만, 커스터마이징이 가능합니다.
Delegate를 통해 데이터를 점진적으로 받아올 수 있습니다.

let url = URL(string: "<https://example.com/data>")!
let defaultSession = URLSession(configuration: .default)
defaultSession.dataTask(with: url) { data, response, error in
    // 응답 처리
}.resume()

Ephemeral Session

캐시, 쿠키, 인증 정보를 디스크에 저장하지 않아 시크릿 모드와 유사합니다.

let url = URL(string: "<https://example.com/data>")!
let ephemeralSession = URLSession(configuration: .ephemeral)
ephemeralSession.dataTask(with: url) { data, response, error in
    // 응답 처리
}.resume()

Background Session

앱이 백그라운드 상태이거나 종료되어도 데이터 전송이 가능합니다.

let url = URL(string: "<https://example.com/data>")!
let config = URLSessionConfiguration.background(withIdentifier: "com.example.app.background")
let backgroundSession = URLSession(configuration: config)
backgroundSession.dataTask(with: url) { data, response, error in
    // 응답 처리
}.resume()

URLSessionTask 종류 (어떤 요청을 보낼지 Task에 대한 종류)

URLSession은 다양한 작업을 처리하기 위해 네 가지 주요 Task를 제공합니다:

DataTask
- NSData 객체를 사용하여 데이터를 전송하고 받습니다.
- 짧고 빈번한 요청에 적합하며, 주로 HTTP GET 요청을 처리합니다.
UploadTask
- 데이터를 서버로 업로드할 때 사용합니다.
- 앱이 실행 중이지 않을 때에도 백그라운드 업로드를 지원합니다.
- 주로 HTTP POST 요청을 처리합니다.
DownloadTask
- 파일 형태로 데이터를 다운로드합니다.
- 앱이 실행 중이지 않을 때에도 백그라운드 다운로드를 지원합니다.
- 주로 HTTP GET 요청을 처리합니다.
StreamTask
- TCP/IP 연결을 생성할 때 사용합니다.(202044021 이준혁)

4. 사용 방법

A. GET 요청

let url = URL(string: "<https://jsonplaceholder.typicode.com/posts>")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let data = data {
        let responseString = String(data: data, encoding: .utf8)
        print(responseString ?? "No Data")
    }
}
task.resume()

B. POST 요청

var request = URLRequest(url: URL(string: "<https://api.example.com/login>")!)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let parameters = ["email": "test@example.com", "password": "1234"]
request.httpBody = try? JSONSerialization.data(withJSONObject: parameters)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        let result = String(data: data, encoding: .utf8)
        print(result ?? "")
    }
}
task.resume()

6. 주의할 점

.resume() 호출 안 하면 요청이 시작되지 않음
비동기 코드이므로 UI 업데이트는 DispatchQueue.main.async에서 해야 함
서버 응답은 statusCode를 통해 반드시 확인해야 함
JSON 디코딩은 Codable을 활용하는 것이 일반적

7. JSON 디코딩 예시

struct Post: Codable {
    let id: Int
    let title: String
}

let url = URL(string: "<https://jsonplaceholder.typicode.com/posts/1>")!
URLSession.shared.dataTask(with: url) { data, _, _ in
    if let data = data {
        let post = try? JSONDecoder().decode(Post.self, from: data)
        print(post?.title ?? "No title")
    }
}.resume()

URLRequest 구성

URLRequest를 사용하여 요청의 세부 사항을 설정할 수 있습니다:

let url = URL(string: "<https://example.com/data>")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

URLResponse 처리

응답은 두 가지 방식으로 처리할 수 있습니다:

Completion Handler

요청이 완료되면 한 번 호출됩니다.

let url = URL(string: "<https://example.com/data>")!
let defaultSession = URLSession(configuration: .default)
defaultSession.dataTask(with: url) { data, response, error in
    // 응답 처리
}.resume()

URLSessionDelegate

데이터 수신, 다운로드 진행 상황, 작업 완료 및 오류 발생 시의 처리를 세밀하게 제어할 수 있습니다.

let url = URL(string: "<https://example.com/data>")!
let config = URLSessionConfiguration.default
let defaultSession = URLSession(configuration: config, delegate: self, delegateQueue: nil)

defaultSession.dataTask(with: url).resume()

extension ViewController: URLSessionDataDelegate {
    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        // 데이터 수신 처리
    }

    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        // 작업 완료 처리
    }
}

좀더 상세하게 보자

이러한 Delegate 패턴을 활용하면, 대용량 데이터 전송이나 다운로드 진행 상황을 실시간으로 처리하는 데 유용합니다.

class ViewController: UIViewController, URLSessionDataDelegate {

    func getData() {
        let url = URL(string: "https://example.com/data")!
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        let session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)
        let task = session.dataTask(with: request)
        task.resume()
    }

    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        print("Received data: \(data)")
    }

    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        if let error = error {
            print("Error: \(error.localizedDescription)")
        } else {
            print("Data received successfully.")
        }
    }
}

요게 어떻게 보면 URLSession 을 가장 정석적으로 사용하는 코드라고 볼수 있음

async/await 너 누군데?

async/await는 Swift 5.5부터 도입된 비동기 코드 작성을 쉽게 해주는 문법입니다. 기존의 completion handler 기반 URLSession 코드를 더 간결하고 읽기 쉬운 형태로 바꿔줍니다.

1. async/await란?

async: 해당 함수가 비동기적으로 실행됨을 나타냄
await: 비동기 함수를 기다림 (작업이 끝날 때까지 다음 코드 실행을 멈춤)
기존 completion handler보다 가독성이 좋고 오류 처리도 간편

2. 기존 방식 vs async/await

기존 방식

URLSession.shared.dataTask(with: url) { data, response, error in
    // callback 안에서 처리
}.resume()

async/await 방식

let (data, response) = try await URLSession.shared.data(from: url)
// 이어서 처리

3. URLSession + async/await 기본 예제

func fetchPost() async throws -> Post {
    let url = URL(string: "<https://jsonplaceholder.typicode.com/posts/1>")!

    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        throw URLError(.badServerResponse)
    }

    let post = try JSONDecoder().decode(Post.self, from: data)
    return post
}

호출은 이렇게 합니다:

Task {
    do {
        let post = try await fetchPost()
        print(post.title)
    } catch {
        print("에러 발생: \\(error)")
    }
}

4. POST 요청 예제

func login() async throws -> LoginResponse {
    let url = URL(string: "<https://api.example.com/login>")!

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")

    let parameters = ["email": "test@example.com", "password": "1234"]
    request.httpBody = try JSONEncoder().encode(parameters)

    let (data, response) = try await URLSession.shared.data(for: request)

    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        throw URLError(.badServerResponse)
    }

    let result = try JSONDecoder().decode(LoginResponse.self, from: data)
    return result
}

5. 주의할 점

async 함수는 await 없이 호출 불가 → Task { } 안에서 호출하거나 다른 async 함수 내에서 사용해야 함
UI 업데이트는 반드시 MainActor 또는 DispatchQueue.main.async에서 실행해야 함
try await는 에러 처리가 필요 → do-catch로 감싸야 함

6. SwiftUI에서 사용 예시

@MainActor
func loadData() async {
    do {
        let post = try await fetchPost()
        self.title = post.title
    } catch {
        self.errorMessage = error.localizedDescription
    }
}

.onAppear {
    Task {
        await loadData()
    }
}

다 필요없다 이것만 알고 가자 URLSession, async/await 사용법 정리

URLSession 사용 순서 정리

URL 생성 (통신할 주소)
URLRequest 객체 생성 및 설정 (httpMethod, 필요 시 헤더 추가)
URLSession으로 dataTask 생성 (요청 이후 처리할 일을 정의하는 코드 블럭을 정의 completion handler)
1. 내부에서 할일 에러체크, 응답 상태코드 확인, 데이터 응답 객체 JSON 파싱 각 case 별 에러 대응
task.resume()를 통해 실제 실행 !!!!! 위 1,2,3 과정을 정의 했다면 실행을 시켜야함

import Foundation

// 1. URL 생성 (옵셔널 바인딩으로 안전하게 처리)
guard let url = URL(string: "<https://api.example.com/data>") else {
    print("❌ 유효하지 않은 URL")
    return
}

// 2. URLRequest 객체 생성 및 설정
var request = URLRequest(url: url)
request.httpMethod = "GET"  // or "POST", "PUT", "DELETE"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
// 필요 시 헤더 추가 가능
// request.setValue("Bearer ", forHTTPHeaderField: "Authorization")

// 3. URLSession으로 dataTask 생성
let task = URLSession.shared.dataTask(with: request) { data, response, error in
    
    // 4. 에러 체크
    if let error = error {
        print("❌ 네트워크 에러: \\(error.localizedDescription)")
        return
    }

    // 5. 응답 상태코드 확인
    guard let httpResponse = response as? HTTPURLResponse else {
        print("❌ 유효하지 않은 응답 객체")
        return
    }

    print("  상태코드: \\(httpResponse.statusCode)")

    guard (200...299).contains(httpResponse.statusCode) else {
        print("❌ 서버 응답 오류: \\(httpResponse.statusCode)")
        return
    }

    // 6. 데이터 존재 여부 확인 및 JSON 파싱
    guard let data = data else {
        print("❌ 데이터가 없습니다.")
        return
    }

    do {
        // 7. JSON 파싱 (Dictionary 또는 Array 형태)
        if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
            print("✅ 파싱된 JSON: \\(json)")
        } else {
            print("❌ JSON 형식이 Dictionary가 아닙니다.")
        }
    } catch {
        print("❌ JSON 디코딩 실패: \\(error)")
    }
}

// 8. 네트워크 요청 시작
task.resume()

async/await 사용 순서 정리

비동기 처리 작업이 들어가는 함수에 async 키워드 붙이기 async 함수로 만들어 주는 것 (비동기 작업을 하는 함수라고 정의)
반환 타입 = await (비동기 작업 실행) 구조를 꼭 기억하자
1. await 왼쪽은 비동기 작업 실행 이후 받을 값들에 대해서 정의를 하고 await 뒤에 비동기 작업을 실행하는 코드를 위치

async 함수는 await 없이 호출 불가 → Task { } 안에서 호출하거나 다른 async 함수 내에서 사용해야 함
UI 업데이트는 반드시 MainActor 또는 DispatchQueue.main.async에서 실행해야 함
try await는 에러 처리가 필요 → do-catch로 감싸야 함

func fetchPost() async throws -> Post {
    let url = URL(string: "<https://jsonplaceholder.typicode.com/posts/1>")!

// 반환 타입 = await (비동기 작업 실행) 구조를 꼭 기억하자
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        throw URLError(.badServerResponse)
    }

    let post = try JSONDecoder().decode(Post.self, from: data)
    return post
}

호출은 이렇게 합니다:

Task {
    do {
         // 반환 타입 = await (비동기 작업 실행) 구조를 꼭 기억하자
        let post = try await fetchPost()
        print(post.title)
    } catch {
        print("에러 발생: \\(error)")
    }
}

자자 다 떠먹여줄게

특히 헷갈리기 쉬운 async, await, try await, throws 키워드의 의미와 관계를 중심으로

1. async 키워드

의미:

해당 함수가 비동기 함수임을 나타냅니다.
즉, 함수 내에서 비동기 작업을 await로 호출할 수 있게 해줍니다.

특징:

async 함수는 동기 함수에서 직접 호출 불가
반드시 아래 중 하나로 감싸야 함:
- Task { ... } 블록
- 다른 async 함수 내부

2. await 키워드

의미:

비동기 작업의 결과가 완료될 때까지 기다림을 나타냄
await은 단독으로 사용할 수 없고, 반드시 async 함수 안에서만 사용 가능

사용 예:

let (data, response) = try await URLSession.shared.data(for: request)

→ data(for:)는 비동기 메서드이기 때문에 await으로 기다려야 함

3. throws 키워드

의미:

해당 함수가 에러를 던질 수 있음을 나타냄
Swift의 오류 처리 방식인 do-try-catch 문법과 함께 사용

특징:

try 키워드를 통해 오류 가능성이 있는 함수 호출
오류가 발생하면 catch로 넘어감

4. try await 키워드

의미:

await 대상이 에러를 던질 수 있는 비동기 함수일 경우 두 키워드를 함께 사용
await만 써선 부족하고, 반드시 try까지 붙여야 함

정리:

상황 키워드

동기 + 오류 발생 가능	try
비동기 + 오류 발생 불가	await
비동기 + 오류 발생 가능	try await

5. 전체 흐름 구조

함수 정의:

func fetchPost() async throws -> Post

요소 의미

async	비동기 작업 가능
throws	에러 던질 수 있음
-> Post	최종 결과로 Post 타입을 반환

→ 이 함수는 비동기 작업을 기다리고, 에러를 던질 수 있고, Post 타입 결과를 돌려줌

함수 내부:

let (data, response) = try await URLSession.shared.data(for: request)

URLSession.shared.data(for:): 비동기 함수 + throws
따라서 → try await 필요

함수 호출:

Task {
    do {
        let post = try await fetchPost()
    } catch {
        print("에러 발생: \\(error)")
    }
}

fetchPost()는 async throws 함수
따라서 호출은 반드시 try await로, 그리고 do-catch로 감싸야 함

Task { }는 Swift에서 비동기 작업을 시작할 수 있는 스레드-safe한 방법

async 함수는 일반 함수에서 직접 호출할 수 없기 때문에, 비동기 함수 호출을 감싸는 컨테이너의 역할을 담당

핵심 포인트

상황 써야 할 키워드 예시

비동기 함수 정의	async	func foo() async {}
에러 던질 수 있음	throws	func foo() throws {}
에러 + 비동기	async throws	func foo() async throws {}
에러나는 동기 호출	try	try JSONDecoder().decode(...)
에러 안 나는 비동기 호출	await	await delay(1)
에러 나는 비동기 호출	try await	try await URLSession.shared.data(for: request)

요약

async는 "이 함수는 기다려야 해!"
await는 "이 작업이 끝날 때까지 기다릴게!"
throws는 "이 함수는 실패할 수 있어!"
try는 "실패할 수 있으니 조심해서 실행해!"
try await는 "실패할 수 있는 비동기 작업을 기다릴게!"

SOPT 4주차 실습 코드로 한번 봐보자

우리 실습 코드는 URLSession, async/await 구조가 섞여 있는 구조임

//
//  RegisterService.swift
//  Week_04
//
//  Created by 정정욱 on 5/3/25.
//

import Foundation

// MARK: - RegisterService (Singleton 패턴)
class RegisterService {

    static let shared = RegisterService() // 싱글톤 인스턴스
    private init() {} // 외부에서 인스턴스 생성 방지

    //MARK: 회원가입 요청 바디 생성 함수 - JSON 데이터 생성
    // URL Session에 넣어줄 URL 요청 객체만을 만드는 부분
    func makeRequestBody(loginId: String, password: String, nickName: String) -> Data? {
        do {
            let data = RegisterRequest(
                loginId: loginId,
                password: password,
                nickname: nickName
            )
            let jsonEncoder = JSONEncoder()
            let requestBody = try jsonEncoder.encode(data)
            return requestBody
        } catch {
            print("  Encoding error: \\(error)")
            return nil
        }
    }

    // MARK: URLRequest 생성 함수 - URL, 메서드, 헤더, 바디
     // URLRequest 객체 생성 및 설정 (httpMethod,  필요 시 헤더 추가)
    func makeRequest(body: Data?) -> URLRequest {
        let url = URL(string: "http://......")! 
        var request = URLRequest(url: url) 
        request.httpMethod = "POST" 
        let header = ["Content-Type": "application/json"] 
        header.forEach {
            request.addValue($0.value, forHTTPHeaderField: $0.key)
        }
        if let body = body {
            request.httpBody = body
        }
        // 이후에 아까 받아온 Body를 넣어줌

        return request
    }

    // MARK: 회원가입 요청 함수 - 서버 통신 
    // - try await을 사용함
    func PostRegisterData(loginId: String, password: String, nickName: String) async throws -> RegisterUserInfo {

        // makeRequestBody 함수를 이용해서, 리퀘스트 바디를 만들어줍니다! 실패할 경우, 아까 NetworkError에서 선언한 오류들을 던지게 됩니다
        guard let body = makeRequestBody(
            loginId: loginId,
            password: password,
            nickName: nickName
        ) else {
            throw NetworkError.requestEncodingError
        }

        let request = self.makeRequest(body: body)
        let (data, response) = try await URLSession.shared.data(for: request)
        dump(request)

        // 응답 유효성 검사
        guard let httpResponse = response as? HTTPURLResponse else {
            throw NetworkError.responseError
        }

        dump(response)

        guard (200...299).contains(httpResponse.statusCode) else {
            throw configureHTTPError(errorCode: httpResponse.statusCode)
        }

        // 문제 없으면 디코딩 수행
        do {
            let decoded = try JSONDecoder().decode(RegisterResponse.self, from: data)
            return decoded.data // 결국 정상 반환시 리턴 값
        } catch {
            print("디코딩 실패:", error)
            throw NetworkError.responseError
        }
    }

    private func configureHTTPError(errorCode: Int) -> Error {
        return NetworkError(rawValue: errorCode)
        ?? NetworkError.unknownError
    }
}

RegisterService는 URLSession을 async/await 방식으로 사용하는 구조라서 dataTask(with:) { ... }.resume() 방식의 task 객체가 코드에 드러나지 않음

전통적인 URLSession 코드:

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    ...
}
task.resume()

하지만 지금 사용하신 구조는 Swift의 async/await 기반의 URLSession.shared.data(for:) 를 사용한 방식

let (data, response) = try await URLSession.shared.data(for: request)

여기서 중요한 건:

data(for:)는 내부적으로 URLSessionDataTask를 생성하고 resume()까지 자동으로 처리해줍니다.

즉, 평소에 보던 task는 암묵적으로 생성되고 실행되기 때문에 코드에서 task 객체가 직접적으로 보이지 않음

RegisterService 흐름 정리

아래는 RegisterService의 네트워크 흐름을 요약한 순서입니다:

makeRequestBody(...)
- Encodable 모델을 JSON 형식으로 Data로 변환
makeRequest(...)
- POST, Header 설정, body 삽입
URLSession.shared.data(for: request)
- 네트워크 요청 비동기 실행
- 내부에서 DataTask가 자동 생성 및 실행
response에서 status code 검사
성공 시 JSON → RegisterResponse로 디코딩

참고로 내부에서 무슨 일이 일어나는가?

let (data, response) = try await URLSession.shared.data(for: request)

이 한 줄은 다음을 포함합니다:

URLSessionDataTask 생성
resume() 호출
응답이 올 때까지 suspension
응답 오면 data, response 리턴 or throw

참고

https://1000one.tistory.com/58

나는 이번 API 통신 과제를 어떻게 했는가

Feat/#1 network learning by jeonguk29 · Pull Request #2 · AT-SOPT-iOS/Jeonguk_practice

What is the PR? 세미나때 배운 네트워크 통신 내용을 기반으로 API 네트워크 레이어 추상화 구조 구현 Changes API 네트워크 레이어 추상화 구조 구현 로그인, 회원가입 API 연결 로그인 id KeychainM

github.com

해당 부분을 좀 살펴보자

이번에 HTTP 통신을 진행하기 위해 네트워크 관련 작업을 기능별, 책임별로 나눴고 추상화를 통해 네트워크 통신을 하도록 만들었음 URLSession 만을 사용하라는 요구사항이 있었는데 사실 해당 구조는 얼핏 본다면 Moya 라이브러리의 구조와 비슷하다고 볼 수도 있음

"역할별로 나눴다"는 건 무슨 말?

네트워크 관련 작업을 기능별, 책임별로 나눠서 관리한다는 뜻

즉, 하나의 파일에 모든 걸 몰아넣는 게 아니라, 누가 뭘 할지 명확하게 나눴음

역할 파일 하는 일

어떤 API를 요청할지 정리	Endpoint.swift	URL 경로와 메서드 정의
HTTP 메서드 정의	HTTPMethod.swift	GET, POST 등을 enum으로 표현
실제 요청 실행	APIService.swift	URLSession 사용해서 요청 보내기
로그인/회원가입 등 호출	AuthService.swift	위 기능들을 모아서 비즈니스로직 제공

이게 바로 "역할별 분리"

하나하나 파일을 살펴보자

일단 네트워크 에러 정의 코드

enum NetworkError: Int, Error, CustomStringConvertible {
    var description: String { self.errorDescription }
    case requestEncodingError
    case responseDecodingError = 1
    case responseError
    case unknownError
    case loginFailed = 400
    case internalServerError = 500
    case notFoundError = 404
    case invalidURL

    var errorDescription: String {
        switch self {
        case .loginFailed: return "로그인에 실패하였습니다."
        case .requestEncodingError: return "REQUEST_ENCODING_ERROR"
        case .responseError: return "RESPONSE_ERROR"
        case .responseDecodingError: return "RESPONSE_DECODING_ERROR"
        case .unknownError: return "UNKNOWN_ERROR"
        case .internalServerError: return "500:INTERNAL_SERVER_ERROR"
        case .notFoundError: return "404:NOT_FOUND_ERROR"
        case .invalidURL: return "잘못된 URL 입니다."
        }
    }
}

설명

전체 구조이 한 줄에 들어있는 뜻키워드 의미

enum	열거형: 정해진 케이스 집합을 나타냄
: Int	각 케이스에 숫자(Int) 원시값을 부여할 수 있게 함
Error	Swift의 표준 에러 처리용 프로토콜 채택 (try/catch용)
CustomStringConvertible	description 문자열을 커스터마이징할 수 있게 함

열거형 케이스 정의

case requestEncodingError → rawValue가 0 (기본값)
case responseDecodingError = 1 → 명시적으로 1
이후는 자동 증가됨 (단, 400, 404, 500처럼 직접 지정한 케이스도 있음)

즉:

Error 프로토콜이 뭐야?

Swift의 try, catch, throw 구문에서 사용할 수 있는 "에러 타입"으로 만들겠다는 뜻입니다.
즉, 아래처럼 사용할 수 있게 됨:

throw NetworkError.loginFailed

CustomStringConvertible은 뭐야?

print(error) 또는 print("\\(error)")처럼 출력할 때 자동으로 description을 사용하게 해주는 프로토콜이에요.
description은 String 타입으로 반환되어야 함
여기서 description은 self.errorDescription을 그대로 가져다 씀

그럼 self.errorDescription은 뭐야?

이건 계산 속성(computed property) 이라고 해요.
description은 실제로는 errorDescription이라는 다른 커스텀 프로퍼티를 간접 참조하고 있는 셈이에요.

즉:이렇게 사용할 수 있음!

열거형 안에 변수/함수를 넣을 수 있나?→ enum은 거의 struct와 비슷하게 행동할 수 있는 강력한 타입이에요.

목적:

서버 상태 코드나 앱 내부 네트워크 오류를 하나의 타입(NetworkError)로 표현
throw와 catch에서 오류를 처리할 수 있도록 Error 채택
로그에 출력하거나 사용자에게 보여줄 메시지를 깔끔하게 만들기 위해 description 정의
Int 원시값을 주어서 상태코드 대응도 쉽게 함

정리 요약

요소 설명

enum NetworkError: Int, Error	에러 처리용 열거형 (상태코드 대응)
CustomStringConvertible	출력 시 설명 텍스트 제공
description: String	실제로는 errorDescription을 가져옴
var errorDescription: String	각 케이스에 대한 사용자 친화 메시지 정의
rawValue	HTTP 상태코드와 연동 가능 (예: 400, 404, 500 등)

HTTPMethod 정의 코드

enum HTTPMethod: String {
    case GET, POST, PATCH, PUT, DELETE
}

열거형을 통해 앱에서 사용할 API의 경로(path)와 HTTP 메서드(method)를

정리하고 구조화한 코드, 서버와 통신할 때 필요한 “주소”와 “방식”을 정리해놓은 API 전화번호 부 역할

//
//  Endpoint.swift
//  Week_04
//
//  Created by 정정욱 on 5/6/25.
//

import Foundation

enum Endpoint {

    enum Auth {
        case signup
        case signin

        var path: String {
            switch self {
            case .signup: return "/api/v1/auth/signup"
            case .signin: return "/api/v1/auth/signin"
            }
        }

        var method: HTTPMethod {
            switch self {
            case .signup, .signin: return .POST
            }
        }
    }

    enum User {
        case me
        case all(keyword: String?)
        case update

        var path: String {
            switch self {
            case .me: return "/api/v1/users/me"
            case .all(let keyword):
                if let keyword = keyword, !keyword.isEmpty {
                    // 인코딩시 한글 깨짐 방지
                    return "/api/v1/users?keyword=\\(keyword.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? "")"
                } else {
                    return "/api/v1/users"
                }
            case .update: return "/api/v1/users"
            }
        }

        var method: HTTPMethod {
            switch self {
            case .me, .all: return .GET
            case .update: return .PATCH
            }
        }
    }
}

이 APIService 클래스는 앱의 모든 네트워크 요청을 담당하는 중앙 통신 관리자 역할

즉, 모든 API 요청을 하나의 함수로 통합하고, 재사용성을 높임

//
//  APIService.swift
//  Week_04
//
//  Created by 정정욱 on 5/6/25.
//

import Foundation

final class APIService {
    static let shared = APIService()
    private init() {}

    private let baseURL = "<http://api.atsopt-4.site>"

    func request(
        path: String,
        method: HTTPMethod,
        headers: [String : String]? = nil,
        body: Data? = nil,
        responseType: T.Type
    ) async throws -> T {
        guard let url = URL(string: baseURL + path) else {
            throw NetworkError.invalidURL
        }

        var request = URLRequest(url: url)
        request.httpMethod = method.rawValue
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        if let headers {
            for (key, value) in headers {
                request.setValue(value, forHTTPHeaderField: key)
            }
        }

        request.httpBody = body

        let (data, response) = try await URLSession.shared.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse else {
            throw NetworkError.responseError
        }

        guard (200...299).contains(httpResponse.statusCode) else {
            throw configureHTTPError(errorCode: httpResponse.statusCode)
        }

        do {
            return try JSONDecoder().decode(T.self, from: data)
        } catch {
            throw NetworkError.responseDecodingError
        }
    }

    private func configureHTTPError(errorCode: Int) -> Error {
        return NetworkError(rawValue: errorCode)
        ?? NetworkError.unknownError
    }
}

실제 사용할때 AuthService처럼 사용

전체 역할 요약

final class APIService

final: 상속 금지 (다른 클래스가 이 클래스를 상속하지 못하도록)
shared: 싱글톤(Singleton) 패턴 — 앱 전역에서 하나의 인스턴스를 공유
핵심 메서드: request(...)

결과적으로 이 클래스는 “모든 HTTP 요청을 수행하고 응답을 디코딩해서 반환해주는 역할”을 해요.

1. 싱글톤 정의

static let shared = APIService()
private init() {}

외부에서 new APIService()처럼 새로 만들지 못하게 private init()
오직 APIService.shared로만 접근 가능하게 함

2. 기본 URL 설정

private let baseURL = "<http://apsite>"

모든 API 경로에 앞에 붙는 공통 서버 주소
실제 요청 시 baseURL + path로 완성된 URL 생성

3. 핵심 메서드: request(...)

func request<T: Decodable>(
    path: String,
    method: HTTPMethod,
    headers: [String : String]? = nil,
    body: Data? = nil,
    responseType: T.Type
) async throws -> T

매개변수 설명:

매개변수 의미

path	Endpoint에서 넘겨준 경로 (예: "/api/v1/auth/signup")
method	GET, POST, PATCH 등 (HTTPMethod enum)
headers	추가로 붙일 HTTP 헤더
body	HTTP 요청 body (JSON 등)
responseType	디코딩할 모델 타입 (예: RegisterResponse.self)

4. URL 생성 및 유효성 검사

guard let url = URL(string: baseURL + path) else {
    throw NetworkError.invalidURL
}

문자열을 URL 객체로 만들 수 없는 경우 → 오류 던짐 (invalidURL)

5. URLRequest 설정

var request = URLRequest(url: url)
request.httpMethod = method.rawValue
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

HTTP 메서드 설정 ("GET", "POST" 등)
기본 Content-Type 헤더 설정

6. 추가 헤더 처리

if let headers {
    for (key, value) in headers {
        request.setValue(value, forHTTPHeaderField: key)
    }
}

Authorization, Accept-Language 등 다른 헤더를 동적으로 추가할 수 있도록 확장성 제공

7. HTTP Body 설정

request.httpBody = body

보통 POST나 PATCH 같은 요청은 서버에 데이터를 보내야 하므로 body 필요
미리 JSONEncoder().encode(...) 해서 넘겨줘야 함
요청 객체 즉 Request 객체를 외부에서 받아 삽입

8. URLSession 비동기 요청 실행

let (data, response) = try await URLSession.shared.data(for: request)

실제 HTTP 통신 발생
async/await를 사용하여 비동기 응답 대기
오류 발생 시 바로 throw

9. 응답 검증

guard let httpResponse = response as? HTTPURLResponse else {
    throw NetworkError.responseError
}
guard (200...299).contains(httpResponse.statusCode) else {
    throw configureHTTPError(errorCode: httpResponse.statusCode)
}

response가 HTTP 형식이 아닐 경우 오류
상태 코드가 2xx 범위를 벗어나면 NetworkError로 변환 후 throw

10. 디코딩 처리

return try JSONDecoder().decode(T.self, from: data)

서버로부터 받은 JSON 데이터를 우리가 원하는 모델 타입 T로 디코딩
실패 시 .responseDecodingError 발생

11. 상태 코드에 따른 오류 매핑

private func configureHTTPError(errorCode: Int) -> Error {
    return NetworkError(rawValue: errorCode)
    ?? NetworkError.unknownError
}

예: 404 → .notFoundError, 500 → .internalServerError
정의되지 않은 오류는 .unknownError로 처리

사용 예시

let result = try await APIService.shared.request(
    path: Endpoint.Auth.signup.path,
    method: Endpoint.Auth.signup.method,
    body: encodedBody,
    responseType: RegisterResponse.self
)

→ 서버에서 받은 응답이 RegisterResponse 타입으로 자동 변환되어 반환됨

실제 사용할때 AuthService처럼 사용

//
//  AuthService.swift
//  Week_04
//
//  Created by 정정욱 on 5/6/25.
//

import Foundation

final class AuthService {
    static let shared = AuthService()

    func signup(
        loginId: String,
        password: String,
        nickName: String
    ) async throws -> RegisterUserInfo {

        // 1. Request body 모델 생성 및 인코딩
        let requestModel = RegisterRequest(
            loginId: loginId,
            password: password,
            nickname: nickName
        )
        let encodedBody = try JSONEncoder().encode(requestModel)

        // 2. APIService 통해 요청
        return try await APIService.shared.request(
            path: Endpoint.Auth.signup.path,
            method: Endpoint.Auth.signup.method,
            body: encodedBody,
            responseType: RegisterResponse.self
        ).data // 라서 반환 타입이 RegisterResponseBody임
    }

    func signin(
        loginId: String,
        password: String
    ) async throws -> LoginUserID {

        let requestModel = LoginRequest(
            loginId: loginId,
            password: password
        )
        let encodedBody = try JSONEncoder().encode(requestModel)

        return try await APIService.shared.request(
            path: Endpoint.Auth.signin.path,
            method: Endpoint.Auth.signin.method,
            body: encodedBody,
            responseType: LoginResponse.self
        ).data
    }
}

는 실제 앱에서 사용자가 회원가입(signup) 또는 로그인(signin)

요청을 보낼 때 호출되는 비즈니스 로직 중심의 서비스 클래스

API를 직접 호출하는 게 아니라 그 과정을 깔끔하게 감싸주는 역할

View에서 이렇게 사용

 @objc private func loginButtonTap() {
        Task {
            do {
                let response = try await AuthService.shared.signin(loginId: self.loginId,
                                                                   password: self.password)

                //  Keychain 자체는 Int를 직접 저장할 수 없고, Data 또는 String 형식만 저장 가능
                let userId = response.userID
                let userIdString = String(userId)
                let saved = KeychainManager.shared.save(key: "userId", value: userIdString)
                print("Keychain 저장 성공 여부: \\(saved)")

                let alert = UIAlertController(
                    title: "로그인 성공",
                    message: "토큰 대용 ID로 로그인 성공 (ID: \\(userIdString))",
                    preferredStyle: .alert
                )

                let okAction = UIAlertAction(title: "확인", style: .default)
                alert.addAction(okAction)
                self.present(alert, animated: true)
            } catch {
                let alert = UIAlertController(
                    title: "로그인 실패",
                    message: error.localizedDescription,
                    preferredStyle: .alert
                )
                let okAction = UIAlertAction(title: "확인", style: .default)
                alert.addAction(okAction)
                self.present(alert, animated: true)

                print("로그인 에러:", error)
            }
        }
    }

3. "추상화했다"는 건 무슨 말?

복잡한 것을 단순하게 겉으로만 보이게 감싼다는 뜻이에요.

예를 들어, 사용자는 AuthService.shared.signup(...) 이렇게만 쓰면 되지만,

내부에서는:

URL 경로를 가져오고 (Endpoint)
HTTPMethod를 설정하고 (POST)
JSON으로 인코딩하고
URLRequest를 만들고
URLSession으로 요청하고
응답을 디코딩하고
에러를 구분해서 처리

이 많은 과정이 들어가요.

하지만 개발자는 몰라도 돼요.

왜냐하면 APIService가 이걸 "추상화"해서 감춰줬기 때문이에요.

4. "클린 아키텍처 기반이다"란?

클린 아키텍처(Clean Architecture)의 핵심은 "관심사의 분리"

즉, 한 파일/모듈이 하나의 책임만 가지게 만드는 구조죠.

원칙 네트워크 구조 예시

하나의 컴포넌트는 하나의 책임만	APIService: 요청 전송, Endpoint: URL 정의
비즈니스 로직은 네트워크와 분리	AuthService: 비즈니스 로직 (URLSession 직접 몰라도 됨)
테스트 가능성 향상	각 레이어가 분리돼 있어 모킹 가능

비유로 쉽게 설명해볼게요

편의점에서 커피 주문하기

역할 사람/행동 코드에서 대응하는 것

손님	"커피 하나 주세요"	AuthService.signup() 호출
점원	커피 주문 받아서 기계 작동	APIService
기계	물, 커피, 컵을 조합해서 커피 제조	URLSession, JSON 인코딩, 디코딩
메뉴판	어떤 커피가 있는지 정리	Endpoint, HTTPMethod

손님은 "커피 주세요"만 하면 되죠?

내부에서는 복잡한 과정이 일어나지만, 깔끔하게 감춰져 있어요.

이게 바로 추상화고, 역할 분리, 그리고 클린한 구조입니다.

요약

개념 의미 적용된 코드

네트워크 레이어	서버와 통신하는 부분	APIService, AuthService 등
역할 분리	각 기능을 나눠서 설계	Endpoint, HTTPMethod, APIService, AuthService
추상화	복잡한 내부 로직을 감추고 단순하게 사용	AuthService.signup(...)
클린 아키텍처	관심사 분리 + 재사용성 + 테스트 용이성	전체 구조가 이 철학에 기반

iOS : SwiftUI + TCA 설명 Architecture와 Design Pattern 차이

개발자 aloe — Fri, 9 Aug 2024 16:54:46 +0900

저는 최근 Clean architecture를 프로젝트에 도입하기 위해서 VIP 패턴을 사용하여 개발을 하고 있습니다, 그러다 요즘은 너무나 많이 사용하는 TCA가 궁금해져서 공부를 해보았는데요

TCA란?

iOS 개발에서 언급되는 TCA는 The Composable Architecture의 약자로, Swift 언어를 사용한 iOS 앱 개발에서 점점 더 많이 사용되고 있는 아키텍처 패턴입니다. The Composable Architecture는 Point-Free라는 개발자가 설계한 라이브러리로, 애플리케이션의 상태 관리, 사이드 이펙트 처리, 모듈성, 테스트 가능성을 개선하는 데 중점을 둡니다.

TCA를 사용하는 이유:

상태 관리의 일관성: TCA는 앱의 상태를 중앙에서 관리합니다. 이를 통해 여러 UI 컴포넌트가 동일한 상태를 일관되게 공유하고 업데이트할 수 있습니다. Redux와 유사한 패턴으로, 상태 변화가 단방향으로 이루어지며 예측 가능해집니다.
사이드 이펙트 관리: 네트워크 요청이나 데이터베이스 접근 등 사이드 이펙트를 명확하게 처리할 수 있도록 도와줍니다. 사이드 이펙트는 Effect라는 타입으로 캡슐화되며, 이를 통해 코드의 가독성과 유지보수성을 높일 수 있습니다.
모듈화 및 재사용성: TCA는 애플리케이션의 기능을 작은 모듈로 나눌 수 있게 해줍니다. 이러한 모듈은 독립적으로 개발, 테스트, 유지보수할 수 있으며, 다른 프로젝트나 앱에서도 재사용할 수 있습니다.
테스트 가능성: TCA는 순수 함수와 데이터 기반 상태 관리를 중심으로 설계되어 있어, 테스트가 용이합니다. 애플리케이션의 상태와 액션을 쉽게 시뮬레이션하고, 사이드 이펙트를 테스트할 수 있습니다.
SwiftUI와의 높은 호환성: TCA는 SwiftUI의 데이터 흐름과 자연스럽게 어우러집니다. SwiftUI의 선언적 UI 패턴과 TCA의 상태 관리 및 사이드 이펙트 처리 메커니즘이 잘 맞아 떨어집니다.

요약

TCA는 iOS 앱 개발에서 복잡한 상태 관리, 모듈화, 테스트 가능성을 개선하고자 하는 개발자들에게 유용한 도구입니다. 특히 SwiftUI와의 결합에서 강력한 효과를 발휘해, 점점 더 많은 개발자들이 TCA를 선택하고 있습니다.

Architecture와 Design Pattern 차이를 아시나요? 해당 개념을 정리하지 않고 공부를 하다보니 머리가 아프고 햇갈리는게 만더라구요 (저도 알고 싶지 않았습니다...)

아키텍처와 디자인 패턴: 개념, 차이점, 그리고 이유

소프트웨어 아키텍처와 디자인 패턴은 소프트웨어 설계의 핵심 개념이지만, 그 역할과 적용 범위는 다릅니다. 이 두 가지를 이해하는 것은 고품질 소프트웨어를 설계하고 유지보수하는 데 필수적입니다.

개념을 상세하게 설명했지만 제가 생각하는 주요 키워드 위주로 형광펜을 치겠습니다. 해당 부분 위주로 봐주세요.

1. 소프트웨어 아키텍처 (Software Architecture)

아키텍처는 소프트웨어 시스템의 전반적인 구조를 정의하는 고수준(한 차원 더 높은 단계)의 설계입니다. 이는 시스템의 주요 구성 요소와 그 상호 작용 방식을 정의하며, 프로젝트 전반에 걸쳐 사용됩니다. 아키텍처는 시스템의 구조, 의사소통 방식, 모듈화, 의존성, 확장성 등을 고려합니다.

주요 특징:

전반적인 구조: 아키텍처는 시스템의 전반적인 구조와 큰 그림을 그립니다. 예를 들어, 클린 아키텍처, 레이어드 아키텍처, 마이크로서비스 아키텍처 등이 있습니다.
모듈 간의 관계: 시스템을 구성하는 주요 모듈들이 어떻게 상호작용하는지 정의합니다.
유지보수성: 시스템이 변경되거나 확장될 때 아키텍처는 그 영향도를 최소화하도록 설계됩니다.
성능과 확장성: 아키텍처는 시스템의 성능 및 확장성을 고려하여 설계됩니다.

사용 이유:

유지보수와 확장성: 시스템의 복잡성을 관리하고, 향후 확장 및 변경을 용이하게 합니다.
의사소통의 명확성: 팀 간의 협업을 촉진하며, 모든 팀원이 시스템의 큰 그림을 이해할 수 있도록 돕습니다.
품질 향상: 일관된 아키텍처는 시스템의 안정성과 품질을 높여줍니다.

2. 디자인 패턴 (Design Pattern)

디자인 패턴은 소프트웨어 설계에서 자주 발생하는 문제를 해결하기 위한 반복 가능한 해결책입니다. 이는 특정 문제를 해결하기 위한 구체적인 설계 방법을 제공합니다. 디자인 패턴은 아키텍처보다 낮은 수준에서, 코드의 구조와 구현에 집중합니다.

주요 특징:

구체적인 설계 방법: 디자인 패턴은 특정 상황에서의 문제 해결을 위한 구체적인 코딩 방법을 제공합니다. 예를 들어, 싱글톤 패턴, 팩토리 패턴, 옵저버 패턴 등이 있습니다.
재사용 가능성: 패턴은 반복적으로 사용 가능한 해결책을 제공하여, 코드의 재사용성을 높입니다.
명확한 용어: 패턴은 소프트웨어 설계에 대한 공통 언어를 제공하여, 개발자 간의 의사소통을 용이하게 합니다.

사용 이유:

반복적인 문제 해결: 자주 발생하는 문제를 해결하기 위한 검증된 방법을 제공합니다.
코드 품질 향상: 디자인 패턴을 사용하면 코드의 명확성과 유지보수성을 높일 수 있습니다.
효율성: 디자인 패턴은 이미 검증된 해결책이므로, 개발 시간을 절약하고 오류를 줄일 수 있습니다.

3. 아키텍처와 패턴의 차이점

적용 범위:
- 아키텍처는 시스템 전체의 구조를 다루며, 전반적인 설계와 관련된 의사결정을 포함합니다. 이는 시스템의 모든 모듈과 그 관계를 포괄합니다.
- 디자인 패턴은 특정 문제를 해결하기 위한 특정 모듈이나 코드 수준의 방법을 다룹니다.
수준의 차이:
- 아키텍처는 높은 수준의 개념입니다. 이는 시스템의 전반적인 설계와 목표에 초점을 맞추고, 시스템이 어떻게 구조화되고 동작해야 하는지를 정의합니다.
- 디자인 패턴은 상대적으로 낮은 수준의 구현 세부 사항에 초점을 맞춥니다. 코딩 과정에서의 문제 해결 방법을 제공하며, 구현에 직접적으로 영향을 미칩니다.
유연성:
- 아키텍처는 시스템의 큰 그림을 설정하기 때문에, 초기 단계에서 결정되고 잘 변하지 않습니다.
- 디자인 패턴은 다양한 시점에서 필요에 따라 적용될 수 있으며, 특정 문제에 대한 해결책을 제공합니다.

4. 요약 및 결론

아키텍처는 소프트웨어 시스템의 전반적인 구조와 설계를 다루며, 디자인 패턴은 특정 문제에 대한 반복 가능한 설계 방법을 제공합니다. 아키텍처는 시스템의 큰 그림을 그리고, 패턴은 그 안에서 개별적인 문제를 해결하는 구체적인 방법을 제시합니다.

이 둘은 함께 사용되며, 좋은 아키텍처는 적절한 패턴을 활용하여 시스템의 품질을 높이고, 유지보수성을 향상시킵니다.

TCA도 앱을 개발하는데 있어 전반적인 구조와 큰 그림을 그리기 위해 설계되었다고 보시면 됩니다!

클린 아키텍처와 TCA를 비교해볼까요?

TCA(The Composable Architecture)와 같은 아키텍처는 명확한 구조와 문서가 제공되지만, 클린 아키텍처(Clean Architecture)는 추상적인 개념을 다루기 때문에 이를 구체화하는 방법으로 VIP(VIPER) 패턴이나 다른 디자인 패턴을 사용합니다. 이를 통해 클린 아키텍처의 원칙을 실제 코드로 구현할 수 있습니다.

즉 클린 아키텍처를 구체화 하기 위해서는 개발자가 다양한 디자인 패턴을 비교하고 채택하여 구현을 합니다.

하지만 TCA는 공식문서가 명확하게 있기때문에 보고 이에 맞춰 구현을 하면 됩니다. TCA도 단방향 데이터 흐름 (Unidirectional Data Flow)이라는 것을 사용하는데 밑에서 상세하게 설명하겠습니다.

이제 이를 좀 더 구체적으로 설명해드릴게요.

https://github.com/pointfreeco/swift-composable-architecture

GitHub - pointfreeco/swift-composable-architecture: A library for building applications in a consistent and understandable way,

A library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind. - pointfreeco/swift-composable-architecture

github.com

클린아키텍처는 명확한 가이드는 따로 없습니다.

1. 클린 아키텍처의 개념

클린 아키텍처는 소프트웨어 설계 원칙을 기반으로, 애플리케이션을 모듈화하고 책임을 명확하게 나누어 유지보수성과 확장성을 높이는 것을 목표로 합니다. 이 아키텍처는 **의존성 역전 원칙(DIP)**과 단일 책임 원칙(SRP) 등을 중심으로 설계되며, 애플리케이션의 각 레이어가 서로 독립적으로 동작할 수 있도록 합니다.

클린 아키텍처의 주요 레이어:

엔티티(Entity): 비즈니스 로직과 핵심 규칙을 담고 있습니다. 이들은 애플리케이션의 핵심 기능을 구현하며, 외부 세계와 독립적으로 존재합니다.
유스케이스(Use Case, 또는 인터랙터): 애플리케이션의 특정 기능이나 작업 흐름을 담당합니다. 이 레이어는 엔티티와 상호작용하며, 비즈니스 로직을 실행합니다.
인터페이스 어댑터(Interface Adapters): 유스케이스와 외부 시스템(예: UI, 데이터베이스, 웹 API) 간의 변환을 담당합니다.
프레임워크 및 드라이버(Frameworks & Drivers): 실제 구현(예: UI, 데이터베이스 등)을 담당하며, 시스템의 외곽에 위치합니다.

이러한 레이어 구조는 모듈화된 코드를 작성할 수 있게 해주며, 각 레이어는 독립적으로 테스트 및 유지보수할 수 있습니다. 그러나 클린 아키텍처 자체는 추상적인 개념이기 때문에, 이를 구체적으로 구현하려면 디자인 패턴이 필요합니다.

2. 클린 아키텍처는 추상적이다!!! 구현을 위한 디자인 패턴: VIP와 VIPER

클린 아키텍처의 추상적인 개념을 실제 코드로 구현하기 위해, 다양한 디자인 패턴이 사용됩니다. 특히, iOS 개발에서 VIP와 VIPER 패턴이 클린 아키텍처를 구현하는 데 자주 사용됩니다.

VIP 패턴 (View-Interactor-Presenter):

View: 사용자 인터페이스(UI)를 담당합니다. 사용자의 입력을 받아 인터랙터에게 전달하고, 프레젠터로부터 전달받은 데이터를 화면에 표시합니다.
Interactor: 애플리케이션의 비즈니스 로직을 처리합니다. 유스케이스를 구현하며, View와 Presenter 간의 데이터를 중계합니다.
Presenter: 데이터를 포맷하고, 이를 View에 전달합니다. 또한, 인터랙터로부터 받은 데이터를 View에 알맞게 변환합니다.

VIP 패턴은 각 모듈에 명확한 역할을 부여하여, 코드의 책임을 분리하고 테스트 가능성을 높입니다. 이는 클린 아키텍처의 원칙인 모듈화와 책임 분리(SRP)를 잘 반영합니다.

VIPER 패턴 (View-Interactor-Presenter-Entity-Router):

VIPER은 VIP 패턴을 확장하여, 더 세분화된 구조를 제공합니다.

View: UI 요소와 사용자 인터랙션을 처리합니다.
Interactor: 비즈니스 로직을 담당합니다.
Presenter: 데이터를 View에 전달하고, UI 로직을 처리합니다.
Entity: 비즈니스 엔티티를 나타내며, 데이터 모델을 정의합니다.
Router: 화면 간의 내비게이션과 모듈 간의 전환을 담당합니다.

VIPER 패턴은 클린 아키텍처의 각 레이어를 구체화하여, 모듈 간 의존성을 더 명확히 분리하고, 코드의 구조를 체계적으로 유지할 수 있도록 합니다.

3. 클린 아키텍처와 디자인 패턴의 관계

클린 아키텍처는 소프트웨어의 전반적인 설계 철학과 구조를 다루는 반면, 디자인 패턴(VIP, VIPER 등)은 이 철학을 실질적으로 구현하는 구체적인 방법론입니다.

관계 요약:

클린 아키텍처는 시스템의 전체적인 설계를 정의하며, 이 설계를 구현하기 위한 가이드라인을 제공합니다.
디자인 패턴은 클린 아키텍처의 원칙을 실현하기 위한 도구입니다. VIP, VIPER 패턴은 클린 아키텍처의 모듈화, 책임 분리, 의존성 관리 등의 원칙을 iOS 개발에서 구현할 수 있도록 도와줍니다.

4. 왜 사용하는가?

모듈화와 유지보수성: 클린 아키텍처와 디자인 패턴을 사용하면 애플리케이션을 모듈화하여, 코드의 재사용성과 유지보수성을 크게 향상시킬 수 있습니다.
테스트 가능성: 각 모듈이 독립적으로 동작할 수 있도록 설계되어, 유닛 테스트와 같은 테스트가 용이해집니다.
확장성과 유연성: 새로운 기능을 추가하거나 기존 기능을 변경할 때, 전체 시스템에 미치는 영향을 최소화할 수 있습니다.
책임 분리: 코드의 각 부분이 명확한 역할을 가지고, 이로 인해 시스템의 복잡성을 줄이고 이해하기 쉽게 만듭니다.

TCA(The Composable Architecture)에서는 주로 단방향 데이터 흐름(Unidirectional Data Flow) 패턴을 사용합니다. 이 패턴은 앱의 상태 관리와 비즈니스 로직을 명확하게 구조화하는 데 중점을 둡니다. TCA는 이 패턴을 기반으로 상태(state), 액션(action), 리듀서(reducer), 그리고 환경(environment)을 사용하여 앱의 로직을 구성합니다.

TCA에서 사용하는 주요 패턴:

단방향 데이터 흐름(Unidirectional Data Flow)
- 상태(State): 애플리케이션의 모든 데이터를 포함하는 구조체입니다.
- 액션(Action): 상태 변경을 일으키는 이벤트입니다.
- 리듀서(Reducer): 액션에 따라 상태를 변경하는 순수 함수입니다.
- 환경(Environment): 외부 의존성을 캡슐화하여 애플리케이션 로직과 분리합니다.

이 패턴은 상태 관리의 복잡성을 줄이고 예측 가능성을 높이는 데 중점을 둡니다. Redux에서 영감을 받은 이 패턴은 TCA의 핵심이 됩니다.

TCA의 주요 특징 :

의존성 주입(Dependency Injection)
- TCA에서는 Environment를 통해 외부 의존성을 관리합니다. 이는 테스트 가능성과 모듈화를 촉진 : TCA의 특징
컴포지션(Composition)
- TCA는 리듀서와 상태를 합성하여 더 복잡한 로직을 만들 수 있게 합니다. 이는 시스템을 모듈화하고 재사용성을 높이는 방식 : TCA의 설계 철학
이펙트 관리(Effect Management)
- Effect는 비동기 작업이나 부작용을 처리하는 TCA의 메커니즘입니다. Combine 프레임워크와 함께 사용되며, 비동기 작업을 선언적이고 관리 가능한 방식으로 처리합니다. : TCA의 기능적 특징

요약

패턴: TCA의 핵심 패턴은 단방향 데이터 흐름입니다. 이 패턴은 앱의 상태와 비즈니스 로직을 예측 가능하고 명확하게 관리할 수 있게 합니다.
특징: TCA의 주요 특징으로는 의존성 주입, 컴포지션, 이펙트 관리가 있습니다.

자 이제 코드로 이해를 해볼까요?

저도 해당 강의를 보고 대략적인 감을 잡았습니다. 해당 강의를 보시면서 아래 코드 주석을 읽어 주세요

우선 간단한 카운트 앱을 만들어 보겠습니다.

Counter App

도메인 별로 상태, 액션, 환경, 라우터, 리듀서를 만들어줘야 합니다.

도메인(무언가를 만들때 어떠한 데이터) + 상태

// 도메인(무언가를 만들때 어떠한 데이터) + 상태
// 카운터 화면이라 이러한 구조를 가짐
struct CounterState: Equatable {
    var count = 0
}

// 도메인 + 액션
enum CounterAction: Equatable {
    case addCount // 카운트를 더하는 액션
    case subtractCount // 카운트를 빼는 액션
}

// 도메인 Environment(환경)
struct CounterEnvironment {}

// Reducer : 액션과 상태를 연결 시켜주는 역할 - Effect를 반환함
let counterReducer = Reducer<CounterState, CounterAction, CounterEnvironment> { state, action, environment in
    // 들어온 액션에 따라 상태를 변경
    switch action {
    case .addCount:
        state.count += 1
        return Effect.none // 이펙트를 반환하지는 않지만 상태를 바꿔준것임
    case .subtractCount:
        state.count -= 1
        return Effect.none
    }
}

이팩트는 다시 따로 설명하겠습니다.

이제 뷰는 스토어라는 상태랑 액션을 가지는 친구를 이용하여 소통합니다. 약간 기존의 MVVM을 사용하셨다면 비슷하게 생각하시면 편합니다.

struct CounterView: View {
    
    // 스토어는 상태랑 액션을 가지고 있음 선언만 한거고 넣어주는건 외부 에서
    let store : Store<CounterState, CounterAction>
    
    var body: some View {
        // 스토어를 받는 방법 WithViewStore : 스토어를 받고 할 수 있도록하는 옵져버블이 되는애
        // 스토어랑 스유뷰랑 연결해주는 친구임
        WithViewStore(self.store) { viewStore in
            VStack {
                Text("count: \(viewStore.state.count)") // 스토어가 상태도 가지고 있어서 변경이 됨
                    .padding()
                HStack{
                    // 스토어 == 사령관 : 사령관님 저 이제 더하기 할거에요 하고 알려줘야함
                    Button("더하기", action: { viewStore.send(.addCount) }) // enum으로 다 정의함 
                    Button("뺴기", action: { viewStore.send(.subtractCount) })
                }
            }
        }
    }
}

전체코드



import SwiftUI
import ComposableArchitecture

// 도메인(무언가를 만들때 어떠한 데이터) + 상태
// 카운터 화면이라 이러한 구조를 가짐
struct CounterState: Equatable {
    var count = 0
}

// 도메인 + 액션
enum CounterAction: Equatable {
    case addCount // 카운트를 더하는 액션
    case subtractCount // 카운트를 빼는 액션
}

// 도메인 Environment(환경)
struct CounterEnvironment {}

// Reducer : 액션과 상태를 연결 시켜주는 역할 - Effect를 반환함
let counterReducer = Reducer<CounterState, CounterAction, CounterEnvironment> { state, action, environment in
    // 들어온 액션에 따라 상태를 변경
    switch action {
    case .addCount:
        state.count += 1
        return Effect.none // 이펙트를 반환하지는 않지만 상태를 바꿔준것임
    case .subtractCount:
        state.count -= 1
        return Effect.none
    }
}

struct CounterView: View {
    
    // 스토어는 상태랑 액션을 가지고 있음 선언만 한거고 넣어주는건 외부 에서
    let store : Store<CounterState, CounterAction>
    
    var body: some View {
        // 스토어를 받는 방법 WithViewStore : 스토어를 받고 할 수 있도록하는 옵져버블이 되는애
        // 스토어랑 스유 뷰랑 연결해주는 친구임
        WithViewStore(self.store) { viewStore in
            VStack {
                Text("count: \(viewStore.state.count)") // 스토어가 상태도 가지고 있어서 변경이 됨
                    .padding()
                HStack{
                    // 스토어 == 사령관 : 사령관님 저 이제 더하기 할거에요 하고 알려줘야함
                    Button("더하기", action: { viewStore.send(.addCount) }) // 이넘으로 다 정의함 
                    Button("뺴기", action: { viewStore.send(.subtractCount) })
                }
            }
        }
    }
}

//struct CounterView_Previews: PreviewProvider {
//    static var previews: some View {
//        CounterView()
//    }
//}

store는 외부에서 주입해주는 방식으로 사용하면 됩니다.



import SwiftUI
import ComposableArchitecture

@main
struct TCA_Simple_tutorialApp: App {
    
    // 외부에서 Store를 생성
    let counterStore = Store(initialState: CounterState(),
                             reducer: counterReducer,
                             environment: CounterEnvironment())
    
  
    
    var body: some Scene {
        WindowGroup {
            CounterView(store: counterStore)
           
        }
    }
}

Memo App (서버와 통신 및 Environment(환경) 사용하기)

import Foundation

// MARK: - MemoElement
struct Memo: Codable, Equatable, Identifiable {
    let createdAt, title, viewCount, id: String
}

typealias Memos = [Memo] // 별칭 주기

API 호출시 해당 구조로 날아온다고 생각

API 통신 작업을 정의

https://elisha0103.tistory.com/26

TCA(The Composable Architecture)란?

최근에 TCA에 관련되어 자료조사할 일이 생겨서 TCA 공식 문서와 공식 업데이트, 개발 방향에 대해 공부한 것을 정리해보려고 한다. TCA pointfree에서 Brandon Williams와 Stephen Ceils가 만들어낸 아키텍처

elisha0103.tistory.com

환경(Environment): API 클라이언트나 애널리틱스 클라이언트와 같이 어플리케이션이 필요로 하는 의존성(Dependency)을 가지고 있는 타입 결국 환경 쪽에서 해당 MemoClient를 가지게 됩니다. (외부에서 소통을 하는 HTTP 통신과 같은 애들을 따로 구현한다음 환경에서 가지고 있다가 Reducer가 해당 환경을 통해 Effect를 받는 구조 입니다.)

Effect는 Composable 밖에서 외부에서 일어나는것들을 다시 Composable로 들어와서 Composable에서 상태를 변경할때

SideEffect, Effect 라고함 보통 사이드 이펙트라고 함 (보통은 데이터 처리)

쉽게 외부에서 일어난 일을 다시 스토어로 가져와 상태를 변경시킬때 이팩트를 쓰는 거군아 라고 생각하면 됨


import Foundation
import ComposableArchitecture

// API 통신

// 통신쪽에 대한 행위들을 정의
struct MemoClient {
    
    /// 단일 아이템 조회
    var fetchMemoItem: (_ id: String) -> Effect<Memo, Failure>
    
    var fetchMemos: () -> Effect<Memos, Failure>
    
    struct Failure : Error, Equatable {} // 에러 정의
    // ComposableArchitecture를 사용할때 거의 대부분 데이터들 Equatable로 되어 있음
}

// 실제 로직처리
extension MemoClient {
    /*
     live는 MemoClient 자체를 반환 하는 것임
     live = MemoClient()  두 문법은 같음
     live = Self()
     */
    static let live = Self(
        
        // fetchMemoItem 클로저로 정의 했음 id를 받음
        fetchMemoItem: { id in
            Effect.task{
                let (data, _) = try await URLSession.shared
                    .data(from: URL(string: "https://603fca51d9528500176060fc.mockapi.io/api/01/todos/\(id)")!)
                return try JSONDecoder().decode(Memo.self, from: data) // 디코딩
            }
            .mapError { _ in Failure() } // 에러가 나면 내가 정의한 형태로 변환
            .eraseToEffect() //퍼블리셔 랑 똑같음 어떤것이든 Effect로 만들어줌 
        }, fetchMemos: {
            Effect.task{
                let (data, _) = try await URLSession.shared
                    .data(from: URL(string: "https://603fca51d9528500176060fc.mockapi.io/api/01/todos/")!)
                return try JSONDecoder().decode([Memo].self, from: data)
            }
            .mapError { _ in Failure() }
            .eraseToEffect()
        }
    )
}

그래서 현제 API 통신이라 반환값이 Effect임 Effect들어가서 보면 퍼블리셔임 결과, 에러가 있음

Effect<Output, Failure: Error>: Publisher

이제 아까와 같이 도메인 별로 상태, 액션, 환경, 라우터, 리듀서를 만들어줘야 합니다.

//
//  MemoView.swift
//  TCA_Simple_tutorial
//
//  Created by Jeff Jeong on 2022/08/04.
//

import Foundation
import SwiftUI
import ComposableArchitecture

// 도메인 + 상태
struct MemoState: Equatable {
    var memos : [Memo] = []
    var selectedMemo : Memo? = nil
    var isLoading : Bool = false
}

// 도메인 + 액션 (약간 뷰모델을 정의하는 듯한 느낌인데)
enum MemoAction: Equatable {
    case fetchItem(_ id: String) // 단일 조회 액션
    case fetchItemResponse(Result<Memo, MemoClient.Failure>) // 단일 조회 액션 응답
    case fetchAll // 모두 조회 액션
    case fetchAllResponse(Result<[Memo], MemoClient.Failure>) // 모두 조회 액션 응답
}

// 환경설정 주입 (여기서 주입이 됨)
struct MemoEnvironment {
    var memoClient : MemoClient // API 호출위해 필요한 녀석
    var mainQueue: AnySchedulerOf<DispatchQueue> // 어떤 스레드에서 할건지
}

// 상태와 액션을 가지고 있는 리듀서
// 액션이 들어왔을때 상태를 변경하는 부분
let memoReducer = Reducer<MemoState, MemoAction, MemoEnvironment> { state, action, environment in
    // 들어온 액션에 따라 상태를 변경
    switch action {
    case .fetchItem(let memoId): // 액션이 들어왔을때 행동을 정의
        enum FetchItemId {} // 이건 정대리도 모름 하나의 사용방법
        state.isLoading = true  // 상태 넣어주기
        return environment.memoClient
            .fetchMemoItem(memoId) // api 호출 환경설정을 통해
            .debounce(id: FetchItemId.self,
                      for: 0.3,
                      scheduler: environment.mainQueue) // 스레드 설정
            .catchToEffect(MemoAction.fetchItemResponse) // 다른 행위 액션으로 이동 (즉 액션간의 이동 처리 방법)
    
        // Result 타입이라 성공, 실패 각각 정의
    case .fetchItemResponse(.success(let memo)):
        state.selectedMemo = memo
        state.isLoading = false
        return Effect.none
    case .fetchItemResponse(.failure): // 상태로 들어와 변경 : 이팩트 = 외부에서 일어나는 결과로 상태를 변경
        state.selectedMemo = nil
        state.isLoading = false
        return Effect.none
    case .fetchAll:
        enum FetchAllId {}
        state.isLoading = true
        return environment.memoClient
            .fetchMemos()
            .debounce(id: FetchAllId.self,
                      for: 0.3,
                      scheduler: environment.mainQueue)
            .catchToEffect(MemoAction.fetchAllResponse)
    case .fetchAllResponse(.success(let memos)):
        state.memos = memos
        state.isLoading = false
        return Effect.none
    case .fetchAllResponse(.failure):
        state.memos = []
        state.isLoading = false
        return Effect.none
    }
}


struct MemoView: View {
    
    let store : Store<MemoState, MemoAction>
    
    var body: some View {
        WithViewStore(self.store) { viewStore in
            
            ZStack {
                
                if viewStore.state.isLoading {
                    Color.black.opacity(0.3)
                        .edgesIgnoringSafeArea(.all)
                        .overlay{
                            ProgressView().tint(.white)
                                .scaleEffect(1.7)
                        }.zIndex(1)
                }
                
                List{
                    Section(header:
                        VStack(spacing: 8) {
                            Button("메모 목록 가져오기", action: {
                                viewStore.send(.fetchAll, animation: .default)
                            })
                            Text("선택된 메모정보")
                            Text(viewStore.state.selectedMemo?.id ?? "비어있음")
                            Text(viewStore.state.selectedMemo?.title ?? "비어있음")
                        }
                    ,
                        content: {
                        ForEach(viewStore.state.memos) { aMemo in
                            // 하나씩 나온 memo 누르면 개별 호출을 하기위해 버튼 생성 
                            Button(aMemo.title, action: {
                                viewStore.send(.fetchItem(aMemo.id), animation: .default)
                            })
                        }
                    })
                }.listStyle(PlainListStyle())
            }
        }
    }
}



import SwiftUI
import ComposableArchitecture

@main
struct TCA_Simple_tutorialApp: App {
    
    // 외부에서 Store를 생성
    let counterStore = Store(initialState: CounterState(),
                             reducer: counterReducer,
                             environment: CounterEnvironment())
    
    let memoStore = Store(initialState: MemoState(),
                          reducer: memoReducer,
                          environment: MemoEnvironment(
                            memoClient: MemoClient.live, // 클라이언트 만들어서 넣어줘야함 (스테틱으로 정의된)
                            mainQueue: .main
                          ))
    
    var body: some Scene {
        WindowGroup {
            //CounterView(store: counterStore)
            MemoView(store: memoStore)
        }
    }
}

MapKit with SwiftUI 기초부터 심화까지 2 : MapKit 다루기 심화 과정

개발자 aloe — Tue, 9 Jan 2024 09:22:55 +0900

이전시간에는 롯데타워 주변에 주차장과, 병원을 Marker로 찍어 봤습니다!

이번 시간에는 좀 더 심화한 내용인

지도의 카메라 개념
지도의 영역 값을 얻는 방법
지도의 영역 값을 기준으로 특정 장소(주차장, 병원)를 검색하는 방법
MKLookAroundScene을 사용하여 프리뷰를 보는 방법
사용자의 현 위치를 기점으로 특정 장소와의 거리 계산 표시 방법 등

다양한 심화 내용을 학습해 보겠습니다.

최종적으로 아래와 같은 앱을 만들어 볼거에요!!

지도를 부산, 강릉으로 이동시켜 보자

롯데타워에서 멀리 이동하여 주차장, 병원을 검색하면 지도에 롯데타워 근처의 결과가 더 이상 자동으로 표시되지 않습니다.
사용자가 지도와 상호작용한 후 검색 결과를 표시하려면 지도가 마커의 프레임이 되도록 지도의 카메라 위치 상태를 다시 설정해야 합니다.

바다가 이쁜 부산, 강릉 위도 경도를 이용해서 버튼을 누르면 해당 지역으로 이동할 수 있게
그리고 롯데타워 주변 주차장, 병원 버튼을 누르면 자동으로 이동할 수 있게 지도의 카메라를 조절해 보겠습니다.

extension MKCoordinateRegion {
    static let busan = MKCoordinateRegion (
        center: CLLocationCoordinate2D( latitude: 35.1795543, longitude: 129.0756416),
        span: MKCoordinateSpan ( latitudeDelta: 0.1, longitudeDelta: 0.1)
    ) // 부산 좌표
    
    static let gangneung = MKCoordinateRegion (
        center: CLLocationCoordinate2D( latitude: 37.751853, longitude: 128.8760574),
        span: MKCoordinateSpan( latitudeDelta: 0.5, longitudeDelta: 0.5)
    ) // 강릉 좌표
}

span이 뭐지?

span은 지도의 경도 및 위도 방향으로 얼마나 넓게 보여줄지에 대한 값입니다.

MKCoordinateSpan 클래스를 사용하여 정의하며, latitudeDelta는 위도 방향으로의 크기, longitudeDelta는 경도 방향으로의 크기를 나타냅니다.

여기서 주어진 코드에서 span은 두 개의 MKCoordinateRegion에 대해 각각 다르게 설정되어 있습니다:

busan: **latitudeDelta**와 **longitudeDelta**가 모두 0.1로 설정되어 있습니다. 이는 부산 지역을 표시할 때, 지도가 위도와 경도 방향으로 각각 0.1만큼의 범위를 갖도록 하는 것입니다.
gangneung: **latitudeDelta**와 **longitudeDelta**가 모두 0.5로 설정되어 있습니다. 이는 강릉 지역을 표시할 때, 지도가 위도와 경도 방향으로 각각 0.5만큼의 범위를 갖도록 하는 것입니다.

따라서 span을 조절하면 지도의 확대 수준이나 축소 수준을 조절할 수 있습니다. 더 큰 latitudeDelta 및 longitudeDelta 값은 더 큰 영역을 보여주게 되어 지도가 더 크게 확대됨을 의미합니다.

⭐️⭐️⭐️

// 카메라 위치추적 변수 지도에 추가한 콘텐츠를 화면에 잡아주는 기본 automatic
    @State private var position: MapCameraPosition = .automatic

MapCameraPosition은 MapKit에서 사용되는 열거형(enumeration)으로, 지도의 카메라 위치와 관련된 여러 가지 옵션을 나타냅니다. 이 열거형은 Map 뷰의 초기화에서 position 매개변수로 사용되어 카메라의 초기 위치를 설정하거나, 지도를 이동할 때 카메라의 동작을 제어하는 데 사용됩니다.

주요 MapCameraPosition 옵션은 다음과 같습니다:

.automatic: 이 옵션은 지도를 자동으로 이동하게끔 카메라를 설정합니다. 주로 사용자의 현재 위치를 중심으로 지도를 표시하고, 사용자가 이동하면 카메라가 자동으로 이동하여 위치를 유지합니다.
.coordinated(latitude:longitude:latitudeDelta:longitudeDelta:): 이 옵션은 특정 좌표를 중심으로 하고, 지정된 위도와 경도의 범위로 지도를 표시합니다. 주어진 좌표를 중심으로 하되, 사용자의 이동에 따라 자동으로 지도를 갱신하지는 않습니다.
.none: 이 옵션은 카메라를 사용하지 않고, 특정 위치로 이동하지 않습니다. 즉, 초기 지도 상태를 고정시킵니다.

이러한 옵션들은 Map 뷰를 초기화할 때 position 매개변수에 전달되어 사용되며, 사용자가 지도와 상호 작용할 때마다 카메라의 위치를 조정하는 데 사용됩니다. MapCameraPosition을 통해 지도를 초기화하고 설정함으로써 사용자에게 더 편리하고 직관적인 지도 경험을 제공할 수 있습니다.

전체코드

//
//  ContentView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

extension CLLocationCoordinate2D {
    static let lotteTower = CLLocationCoordinate2D(latitude: 37.5125, longitude: 127.102778)
}

extension MKCoordinateRegion {
    static let busan = MKCoordinateRegion (
        center: CLLocationCoordinate2D( latitude: 35.1795543, longitude: 129.0756416),
        span: MKCoordinateSpan ( latitudeDelta: 0.1, longitudeDelta: 0.1)
    ) // 도시좌표
    
    static let gangneung = MKCoordinateRegion (
        center: CLLocationCoordinate2D( latitude: 37.751853, longitude: 128.8760574),
        span: MKCoordinateSpan( latitudeDelta: 0.5, longitudeDelta: 0.5)
    ) // 해안 좌표
}


struct ContentView: View {
    
    //   카메라 위치추적 변수 지도에 추가한 콘텐츠를 화면에 잡아주는 기본 automatic
    @State private var position: MapCameraPosition = .automatic
    
     @State private var searchResults: [MKMapItem] = []
    
    var body: some View {
        Map(position: $position){ //   Map의 카메라를 초기화 할수있게 설정
            Annotation("lotteTower", coordinate: .lotteTower) {
                ZStack {
                    RoundedRectangle(cornerRadius: 5)
                        .fill(.background)
                    RoundedRectangle(cornerRadius: 5)
                        .stroke(.secondary, lineWidth: 5)
                    Image(systemName: "house.circle.fill")
                        .padding(5)
                }
            }
            .annotationTitles(.hidden) 
        
            ForEach(searchResults, id: \.self) { result in
                Marker(item: result)
            }
        }
        .mapStyle(.standard)
        .safeAreaInset(edge: .bottom) {
            HStack {
                Spacer()
                //   $position(카메라)넣어주기
                BeanTownButtons(position:  $position, searchResults: $searchResults)
                    .padding(.top)
                Spacer()
            }
            .background(.ultraThinMaterial)
        }
        .onChange(of: searchResults){
                   position = .automatic //   카메라 업데이트
                   // 이제 다른곳에 있어도 지도를 직접 올려서 찾아 가지 않아도 됨
               }

    }
}


#Preview {
    ContentView()
}

부산, 강릉 이동 버튼 추가

//
//  BeantownButtonView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

struct BeanTownButtons: View {
    
    @Binding var position: MapCameraPosition //   카메라 위치상태 바인딩
    @Binding var searchResults: [MKMapItem]
    
    var body: some View {
        HStack {
            Button {
                search(for: "parking")
            } label: {
                Label("parking lot", systemImage: "car")
            }
            .buttonStyle(.borderedProminent)
            
            Button {
                search(for: "hospital")
            } label: {
                Label("restroom", systemImage: "cross.case")
            }
            .buttonStyle(.borderedProminent)
            
            //  부산, 강릉으로 이동 버튼
            Button {
                position = .region(.busan) // 부산 표시
            } label: {
                Label("Busan", systemImage: "figure.open.water.swim")
            }
            .buttonStyle (.bordered)
            
            Button {
                position = .region(.gangneung) // 강릉 표시
            } label: {
                Label("Gangneung", systemImage: "figure.sailing")
            }
            .buttonStyle (.bordered)
            
        }
        .labelStyle(.iconOnly)
    }
    

    func search(for query: String) {
        let request = MKLocalSearch.Request()
        request.naturalLanguageQuery = query
        request.resultTypes = .pointOfInterest
        request.region = MKCoordinateRegion(
            center: .lotteTower,
            span: MKCoordinateSpan (latitudeDelta: 0.0125, longitudeDelta: 0.0125)
            )

        Task {
            let search = MKLocalSearch(request: request)
            let response = try? await search.start()
            searchResults = response?.mapItems ?? []
        }
    }

}

이번 part에서는

MapCameraPosition을 이용하여 지도의 화면을 조절해 보았습니다.

사용자가 지도를 움직여 보이는 영역에서 검색하기

종로구에서 가까운 주차장, 병원 찾기, 부산지역 주차장 찾기, 강릉지역 병원 찾기

카메라가 바뀔 때 눈앞에 보이는 지도 영역의 값을 얻는 방법

.
.
.

struct ContentView: View {
    
    // 지도에 표시되는 지역을 추적하기 위해 상태를 추가
    @State private var visibleRegion: MKCoordinateRegion?
    
		 .
		 .
		 .

        .mapStyle(.standard)
        .safeAreaInset(edge: .bottom) {
            HStack {
                Spacer()
                // 
                BeanTownButtons(position: $position, searchResults: $searchResults, visibleRegion: visibleRegion)
                    .padding(.top)
                Spacer()
            }
            .background(.ultraThinMaterial)
        }
        .onChange(of: searchResults){
            position = .automatic
        }
        .onMapCameraChange { context in
            visibleRegion = context.region
        }
        /*  
         onMapCameraChange에 제공된 클로저는 사용자가 지도와의 상호작용을 마치면 호출됩니다. 사용자가 지도와 상호작용하는 동안 클로저를 호출하려면 빈도 매개변수를 전달하여 지속적인 업데이트를 요청할 수 있습니다.
         */
    }
}


#Preview {
    ContentView()
}

코드설명

MKCoordinateRegion은 MapKit 프레임워크에서 사용되는 구조체로, 지도의 특정 영역을 정의합니다.

이 구조체는 중심 좌표 (center)와 지도 영역의 크기를 나타내는 스팬 (span)으로 구성됩니다.

center: 중심 좌표는 해당 영역의 지도에서 가운데 위치하는 지점의 위도와 경도입니다.
span: 스팬은 지도 영역의 크기를 나타내며, 위도 방향과 경도 방향의 크기를 각각 latitudeDelta와 longitudeDelta로 정의합니다.

즉 MKCoordinateRegion을 사용하면 특정 지점을 중심으로 하는 지도 영역을 정의할 수 있습니다.

즉 사용자가 바라보고 있는 지도의 한 부분을 저장하기 위한 변수 입니다.

.onMapCameraChange

swiftCopy code
.onMapCameraChange { context in
    visibleRegion = context.region
}

.onMapCameraChange: SwiftUI에서 제공하는 modifier로, 사용자가 지도와의 상호작용을 마치면 호출되는 클로저를 등록하는 역할을 합니다. 사용자가 지도와 상호작용하는 동안 해당 클로저를 지속적으로 호출하려면 빈도 매개변수를 사용할 수 있습니다.
{ context in visibleRegion = context.region }: 클로저 내부에서 context 매개변수를 받아와서 사용합니다. context.region은 사용자가 지도를 조작할 때 현재 지도 영역에 대한 정보를 제공합니다. 이 정보를 사용하여 visibleRegion 상태 변수를 업데이트합니다. 따라서 지도의 카메라가 변경될 때마다 visibleRegion이 해당 지도 영역을 반영하게 됩니다.

이 부분은 지도의 카메라가 변경될 때마다 해당 변경사항을 감지하고, 그에 따라 visibleRegion을 업데이트하여 현재 지도가 보여주는 영역을 추적하는데 사용됩니다.

쉽게 생각해서 이렇게 해주면 사용자가 지도를 움직일 때 보이는 지도의 부분에 대한 영역을 저장할 수 있습니다.

region이 뭔가요?

region은 onMapCameraChange 클로저의 context 매개변수에서 제공되는 속성 중 하나로, 사용자가 지도와의 상호 작용 중에 현재 지도 영역에 대한 정보를 포함합니다. 이 정보는 MKCoordinateRegion 타입으로 제공되며, 지도의 특정 영역을 정의합니다.

MKCoordinateRegion은 다음과 같은 속성을 포함합니다:

center: 중심 좌표는 해당 영역의 지도에서 가운데 위치하는 지점의 위도와 경도입니다.
span: 스팬은 지도 영역의 크기를 나타내며, 위도 방향과 경도 방향의 크기를 각각 **latitudeDelta**와 **longitudeDelta**로 정의합니다.

즉, context.region은 현재 지도의 영역을 정의하는 MKCoordinateRegion 객체를 나타냅니다. 따라서 onMapCameraChange 클로저 내에서 이 정보를 활용하여 지도의 변경사항에 대응하는 데 사용할 수 있습니다.

//
//  BeantownButtonView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

struct BeanTownButtons: View {
    
	  .
		.
		.
    var visibleRegion: MKCoordinateRegion? //   사용자에게 표시되는 지역 내에서 검색되도록 BeantownButton을 업데이트
		.
		.
		.
    

    func search(for query: String) {
        let request = MKLocalSearch.Request()
        request.naturalLanguageQuery = query
        request.resultTypes = .pointOfInterest
				//  검색을 할때 사용자가 바라보고 있는 지도의 한부분에 대한 좌표를 가지고 검색
        request.region = visibleRegion ?? MKCoordinateRegion(
            center: .lotteTower,
            span: MKCoordinateSpan (latitudeDelta: 0.0125, longitudeDelta: 0.0125)
            )

        Task {
            let search = MKLocalSearch(request: request)
            let response = try? await search.start()
            searchResults = response?.mapItems ?? []
        }
    }

}

street view 정보 표시 (지역 Preview, 지역이름, 현 위치로부터 도착 시간)

아쉽게 한국은 MKLookAroundScene 표시가 아직 많이 지원되지 않습니다. 다른 나라를 기준으로 잡고 결과를 확인해 보세요

//
//  ContentView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

struct ContentView: View {
    
    .
		.
		.

    
    @State private var selectedResult: MKMapItem? //여러 결과중 하나 선택하여 담기 위함
    
    // 주차장에서 선택한 검색결과까지 route정보를 구하기
    @State private var route: MKRoute?
    
    var body: some View {
        // selection: $selectedResult 추가
        Map(position: $position, selection: $selectedResult){
          .
					.
					.

        .safeAreaInset(edge: .bottom) {
            HStack {
                Spacer()
                VStack(spacing:0) {
                    //   여러 결과중 하나를 선택하면 해당 선택한 MKMapItem 과 출발지(롯데타워)부터 목적지까지의 거리를 전달
                    if let selectedResult {
                        ItemInfoView(selectedResult: selectedResult, route: route)
                            .frame(height: 128)
                            .clipShape(RoundedRectangle (cornerRadius: 10))
                            .padding([.top, .horizontal])
                    }
                    
                    BeanTownButtons(position: $position, searchResults: $searchResults, visibleRegion: visibleRegion)
                        .padding(.top)
                    
                }
                Spacer()
                
            }
            .background(.ultraThinMaterial)
        }
        .onChange(of: searchResults){
            position = .automatic
            getDirections() // 실행
        }
        .onMapCameraChange { context in
            visibleRegion = context.region
        }
        
    }
    
    
    
    func getDirections() {
        route = nil
        guard let selectedResult else { return }
        let request = MKDirections.Request()
        request.source = MKMapItem(placemark: MKPlacemark(coordinate: .lotteTower))
        request.destination = selectedResult
        
        Task {
            let directions = MKDirections(request: request)
            let response = try? await directions.calculate()
            route = response?.routes.first
        }
    }
    
}


#Preview {
    ContentView()
}

Map(position: $position, selection: $selectedResult) 설명

여기서 selection: $selectedResult를 사용하는 것은 사용자가 지도에서 어떤 지점을 선택했을 때

selectedResult 변수를 업데이트하고자 하는 의도를 나타냅니다.

즉, 사용자가 지도에서 특정 지점을 선택하면 해당 지점에 대한 MKMapItem 정보가 selectedResult에 할당되어, 이를 통해

다양한 작업을 수행할 수 있습니다.

예를 들어, selectedResult가 업데이트될 때마다 길 찾기를 수행하거나 선택된 지점에 대한 추가 정보를 로드하는 등의 작업을 수행할 수 있습니다. 이것은 사용자가 지도에서 특정 위치를 선택할 때 앱이 해당 이벤트에 반응하고 관련된 동작을 수행할 수 있도록 하는 SwiftUI의 편리한 기능 중 하나입니다.
Map 뷰의 selection 매개변수는 사용자가 지도에서 특정 위치를 선택했을 때 해당 위치에 대한 정보를 나타내기 위한 Binding을 나타냅니다. 이것은 사용자가 지도에서 특정 지점을 선택할 때마다 해당 위치에 대한 정보를 업데이트하고 관련된 동작을 수행할 수 있게 해줍니다.

@State private var route: MKRoute?가 무슨 변수이지?

여기서 route 변수는 ContentView에서 현재 선택된 지도 항목(selectedResult)과

"lotteTower"라는 기본 출발지 사이의 길 찾기 정보를 나타냅니다. 사용자가 지도에서 어떤 지점을 선택하면

(selectedResult가 업데이트될 때), getDirections 함수가 호출되어 해당 지점까지의 길 찾기 정보를 구하고 route 변수에 저장됩니다.즉, route 변수는 사용자가 선택한 지점과 출발지 간의 길 찾기 정보를 저장하는 데 사용되며, SwiftUI의 반응형 프레임워크를 활용하여 UI를 업데이트하는 데 활용됩니다.

상태 속성인 @State는 SwiftUI 뷰에서 변경이 감지되면 해당 뷰를 다시 그리게끔 하는 역할을 합니다. 따라서 route 값이 업데이트되면 해당 값을 사용하는 뷰들이 자동으로 업데이트되어 새로운 길 찾기 정보를 표시하게 됩니다.
@State private var route: MKRoute?은 SwiftUI에서 사용되는 상태 속성입니다. 이 상태 속성은 현재 선택된 지도 항목과 MKDirections를 사용하여 해당 항목에 대한 길 찾기 정보(MKRoute)를 저장합니다.

getDirections 메서드는 다음 chapter에서 제대로 활용합니다. 이해하고 넘어와 주세요

import SwiftUI
import MapKit

struct ItemInfoView: View {
    // ItemInfoView의 상태 속성으로 주변보기 씬을 저장하는 변수
    @State private var lookAroundScene: MKLookAroundScene?
    
    // 선택된 지도 항목 및 길 찾기 정보를 나타내는 속성
    let selectedResult: MKMapItem
    let route: MKRoute?

    // 길 찾기 정보의 예상 이동 시간을 포맷팅하는 속성
    private var travelTime: String? {
        // 길 찾기 정보가 있으면 실행
        guard let route else { return nil }
        
        let formatter = DateComponentsFormatter()
        formatter.unitsStyle = .abbreviated
        formatter.allowedUnits = [.hour, .minute]
        
        // 길 찾기 정보의 예상 이동 시간을 포맷팅하여 반환
        return formatter.string(from: route.expectedTravelTime)
    }
    
    var body: some View {
        // 주변보기 씬을 표시하는 뷰
        LookAroundPreview(initialScene: lookAroundScene)
            .overlay(alignment: .bottomTrailing) {
                // 선택된 지도 항목의 이름과 예상 이동 시간을 표시하는 HStack
                HStack {
                    Text("\(selectedResult.name ?? "")")
                    // 예상 이동 시간이 있는 경우 표시
                    if let travelTime {
                        Text(travelTime)
                    }
                }
                .font(.caption)
                .foregroundStyle(.white)
                .padding(10)
            }
            // 뷰가 나타날 때 주변보기 씬을 가져오는 작업 수행
            .onAppear {
                getLookAroundScene()
            }
            // 선택된 지도 항목이 변경될 때마다 주변보기 씬을 업데이트하는 작업 수행
            .onChange(of: selectedResult) {
                getLookAroundScene()
            }
    }

    // 주변보기 이미지를 가져오는 기능
    func getLookAroundScene() {
        // 초기화
        lookAroundScene = nil
        // 비동기 작업 시작
        Task {
            // 선택된 지도 항목의 주변보기 씬 요청
            let request = MKLookAroundSceneRequest(mapItem: selectedResult)
            lookAroundScene = try? await request.scene
        }
    }
}

MKLookAroundScene 타입 설명

MKLookAroundScene?: lookAroundScene은 주변보기(MKLookAroundScene) 씬을 나타내는 변수입니다. MKLookAroundScene은 MapKit에서 제공하는 클래스로, 지도 항목의 주변 환경을 시각적으로 나타내기 위한 3D 씬을 생성하는 데 사용됩니다. 이 변수는 @State로 선언되어 뷰의 상태를 나타냅니다.

getLookAroundScene 메서드에서 해당 주변보기 씬을 가져오고, 이후에 lookAroundScene이 업데이트되면 해당 변경을 SwiftUI에 알려서 뷰를 갱신하게 됩니다.

주변보기 씬은 지도 항목 주변의 실제 환경을 시각적으로 제공하기 위해 사용됩니다. 이것은 사용자가 선택한 위치의 주위를 실제 사진과 같이 볼 수 있게 해주는 기능입니다.

최종 결과물 : 사용자의 현 위치에서 주차장, 병원 찾기 앱

사용자의 현 위치를 계속 추적하여 파악해 보자
사용자가 바라보고 있는 지도 화면을 기준으로 주차장, 병원을 찾아보자
사용자가 하나의 marker를 선택하면 사용자의 현 위치를 기점으로 걸리는 시간 및 경로를 시각화해 보자
지도에 추가적인 컨트롤 요소를 설정해 보자, 나침반, 현 위치로 돌아오기

⭐️ 꼭 권한 설정을 해주고 진행해야 합니다.

전반적으로 코드를 수정했어요. 일단 표시한 코드를 수정, 추가 하고 설명을 읽어주세요. ㅎㅎ

//
//  ContentView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit


//  
@MainActor class LocationsHandler: ObservableObject {
    
    static let shared = LocationsHandler()
    public let manager: CLLocationManager

    init() {
        self.manager = CLLocationManager()
        if self.manager.authorizationStatus == .notDetermined {
            self.manager.requestWhenInUseAuthorization()
        }
    }
}

.
.
.

struct ContentView: View {
    
    @ObservedObject var locationsHandler = LocationsHandler.shared
    
    @State private var visibleRegion: MKCoordinateRegion?

    //  
    @State private var position: MapCameraPosition = .userLocation(followsHeading: true, fallback: .automatic)
    
    
    @State private var searchResults: [MKMapItem] = []
    
    @State private var selectedResult: MKMapItem?
    
    @State private var route: MKRoute?
    

    var body: some View {
  
        Map(position: $position, selection: $selectedResult){
        //                
            ForEach(searchResults, id: \.self) {result in
                Marker(item: result)
            }
            .annotationTitles(.hidden)
            
            if let route {
                MapPolyline(route)
                    .stroke(.blue, lineWidth: 5)
            }

            UserAnnotation()
        }
        .mapStyle(.standard(elevation: .realistic))
        .safeAreaInset(edge: .bottom) {
            HStack {
                Spacer()
                VStack(spacing:0) {
                    if let selectedResult {
                        ItemInfoView(selectedResult: selectedResult, route: route)
                            .frame(height: 128)
                            .clipShape(RoundedRectangle (cornerRadius: 10))
                            .padding([.top, .horizontal])
                    }
                    
                    }//   바라보는 지도의 영역 위치 값을 보내 해당 영역에서 검색 하도록 
                    BeanTownButtons(position: $position, searchResults: $searchResults, visibleRegion: visibleRegion)
                        .padding(.top)
                    
                }
                Spacer()
                
            }
            .background(.ultraThinMaterial)
        }//  
        .onChange(of: searchResults) {
            withAnimation{
                position = .automatic
           }
        }
        .onChange(of: selectedResult) {
            getDirections()
        }
        .onMapCameraChange { context in
            visibleRegion = context.region
        }
				//  
        .mapControls { // 이제 버튼을 탭하여 내 위치를 표시할 수 있습니다. 내가 움직일 때 지도 카메라가 나를 따라다닐 것입니다.
            MapUserLocationButton() // 누르면 내 위치로 바로 이동함, 내가 이동하면 카메라도 이동함
            MapCompass()
            MapScaleView()
            /*
             mapControls 설정은 지도를 회전하면 나침반을 띄우고 화면을 확대하거나 축소하면 축적을 표시함
             */
        }

    }
    
    
    
    func getDirections() {
        route = nil
        guard let selectedResult else { return }
        //  
        let location = locationsHandler.manager.location
        guard let coordinate = location?.coordinate else { return }
				//  
        let request = MKDirections.Request()
        request.source = MKMapItem(placemark: MKPlacemark(coordinate: coordinate))
        request.destination = selectedResult
        
        Task {
            let directions = MKDirections(request: request)
            let response = try? await directions.calculate()
            route = response?.routes.first
        }
    }
    
}


#Preview {
    ContentView()
}

사용자의 현 위치를 계속 추적하여 파악해 보자

코드 설명

@MainActor class LocationsHandler: ObservableObject {

static let shared = LocationsHandler()
public let manager: CLLocationManager

	init() {
	    self.manager = CLLocationManager()
	    if self.manager.authorizationStatus == .notDetermined {
	        self.manager.requestWhenInUseAuthorization()
	    }
	}
}

이 코드는 특정 위치 정보를 다루기 위한 클래스를 정의하고 있습니다.

LocationsHandler라는 클래스는 위치 정보를 다루는 데 도움을 주는 클래스입니다.

이 클래스를 사용하면 위치 정보를 관리하고, 사용자에게 위치 정보 사용 권한을 요청할 수 있습니다.

이 클래스는 ObservableObject 를 채택하여 클래스의 상태가 변할 때 다른 객체들에게 알림을 보낼 수 있게 구현하였습니다. 이렇게 하면 다른 객체들이 위치 정보의 변화를 쉽게 감지하고 반응할 수 있겠죠?

클래스 안에는 manager라는 객체도 있는데. 이 객체는 CLLocationManager 즉 위치 정보를 다루는 데 도움이 되는

여러 기능들을 제공합니다. 클래스의 초기화 메서드인 init()에서는 manager를 초기화하고, 권한 상태를 확인한 뒤,

권한이 설정되어 있지 않은 경우 위치 정보 사용 권한을 요청합니다. 이렇게 하면 사용자에게 위치 정보 사용 권한을 요청할 수 있습니다.

위치 정보 사용 권한을 받으면 앱이 정확한 위치 정보를 이용할 수 있습니다.

요약 싱글톤으로 구현하여 사용자의 현위치 추적 권한을 얻고 계속해서 위치를 추적할수 있습니다.

//  
@State private var position: MapCameraPosition = .userLocation(followsHeading: true, fallback: .automatic)

두 번째로, position 변수는 MapCameraPosition이라는 형식을 가지고 있고, 초기값으로

.userLocation(followsHeading: true, fallback: .automatic)을 가지고 있습니다.

MapCameraPosition은 지도에서 카메라의 위치를 나타내는 열거형(enum)입니다.

position 변수는 이 열거형을 가지고 있으며, 초기값으로 .userLocation(followsHeading: true, fallback: .automatic)을

가지고 있습니다. .userLocation(followsHeading: true, fallback: .automatic)은 MapCameraPosition의 한 경우(case)입니다.

이 경우, 카메라의 위치를 사용자의 현재 위치로 설정합니다. followsHeading 매개변수는 사용자의 위치가 변경될 때마다 카메라가 사용자의 이동 방향을 따라가도록 지정하는 데 사용됩니다.

true로 설정되어 있으므로 카메라는 사용자의 이동 방향을 따라갑니다.

fallback 매개변수는 사용자의 위치를 가져올 수 없는 경우 카메라의 위치를 대체로 설정하는 데 사용됩니다.

.automatic으로 설정되어 있으므로 자동 대체가 이루어집니다.

이 코드는 SwiftUI의 @State 속성을 사용하여 position 변수를 선언하고 초기값을 설정하는 역할을 합니다. position 변수는 지도의 카메라 위치를 나타내며, 초기값으로는 사용자의 위치를 따라가는 설정으로 설정되어 있습니다.

즉 앱이 시작되면 사용자의 위치를 추적해서 사용자 위치 기점으로 맵의 카메라를 조절하여 사용자의 위치를 따라가게 해주고 그렇지 않다면 사용자가 지도를 보는 위치 기점으로 카메라를 따라가겠다는 것입니다.

//  
        .onChange(of: searchResults) {
            withAnimation{
                position = .automatic
           }
        }

그래서 사용자가 주차장, 병원을 찾는 버튼을 누르면 서서히 지도의 카메라를 조절하게 구현하였습니다.

지도에 추가적인 컨트롤 요소를 설정

 .mapControls { // 이제 버튼을 탭하여 내 위치를 표시할 수 있습니다. 내가 움직일 때 지도 카메라가 나를 따라다닐 것입니다.
            MapUserLocationButton() // 누르면 내 위치로 바로 이동함, 내가 이동하면 카메라도 이동함
            MapCompass()
            MapScaleView()
            /*
             mapControls 설정은 지도를 회전하면 나침반을 띄우고 화면을 확대하거나 축소하면 축적을 표시함
             */
 }

주어진 코드는 지도에 추가적인 컨트롤 요소를 설정하는 부분입니다.

.mapControls는 지도에 컨트롤 요소를 추가하는 데 사용되는 메서드입니다.

이 메서드 내에서 다양한 컨트롤 요소를 설정할 수 있습니다.

MapUserLocationButton()은 내 위치를 표시하고, 해당 위치로 바로 이동할 수 있는 버튼입니다.
- 버튼을 누르면 현재 사용자의 위치로 지도가 이동하며, 사용자가 이동하면 지도 카메라도 사용자를 따라다닙니다.
MapCompass()는 지도 회전 시 나침반을 표시하는 요소입니다.
- 지도가 회전하면 나침반이 함께 회전하여 현재 방향을 표시합니다.
MapScaleView()는 화면을 확대하거나 축소할 때 지도의 축척을 표시하는 요소입니다.
- 화면을 확대하거나 축소하면 해당 축척이 지도 상단에 표시됩니다.

이렇게 설정된 mapControls는 지도에 버튼을 추가하여 사용자의 위치를 표시하고, 사용자가 이동할 때 지도 카메라가 따라다니며, 지도 회전 시 나침반을 표시하고, 화면 확대/축소 시 축척을 표시합니다. 이를 통해 사용자는 지도를 더 편리하게 조작할 수 있습니다.

사용자가 하나의 Marker를 선택하면 사용자의 현 위치를 기점으로 걸리는 시간 및 경로를 시각화해 보자

 Map(position: $position, selection: $selectedResult){
        //                
            ForEach(searchResults, id: \.self) {result in
                Marker(item: result)
            }
            .annotationTitles(.hidden)
            
            if let route {
                MapPolyline(route)
                    .stroke(.blue, lineWidth: 5)
            }

            UserAnnotation() // 사용자의 현위치를 표시
        }

맵이 시작하면 일단 사용자의 위치를 표시하다가 사용자가 주차장, 병원 버튼을 누른다면 selectedResult에 값이 들어오게 됩니다.

그래서 그 결과 list를 하나하나 Marker로 표시합니다.

그리고 값이 바뀌면 즉 하나의 Marker를 선택하면

func getDirections() {
        route = nil
        guard let selectedResult else { return }
        //  
        let location = locationsHandler.manager.location
        guard let coordinate = location?.coordinate else { return }
				//  
        let request = MKDirections.Request()
        request.source = MKMapItem(placemark: MKPlacemark(coordinate: coordinate))
        request.destination = selectedResult
        
        Task {
            let directions = MKDirections(request: request)
            let response = try? await directions.calculate()
            route = response?.routes.first
        }
    }

해당 함수가 실행 됩니다.

바로 사용자 현 위치에서 선택한 지점의 거리 계산을 수행하는 getDirections() 함수입니다.

먼저, 함수 내에서 route 변수를 초기화합니다. 이 변수는 경로를 저장하는 역할을 합니다.

그 다음, selectedResult 변수가 nil이 아닌지 확인합니다.(결과 Marker 중 하나를 선택한 값) nil이라면 함수를 종료합니다.

locationsHandler.manager.location을 통해 사용자 현재 위치를 가져옵니다.

이때, 위치 정보가 유효한 경우에만 다음 과정을 수행합니다.

coordinate 변수를 통해 현재 위치의 좌표를 가져옵니다. (사용자 위도, 경도)

request 객체를 생성합니다. 이 객체는 경로 계산에 필요한 정보를 담고 있습니다.

request.source에는 현재 위치를 나타내는 MKMapItem 객체를 설정합니다.

이때, 좌표를 활용하여 MKPlacemark 객체를 생성하고, 이를 MKMapItem에 설정합니다.

request.destination에는 경로의 목적지를 설정합니다. selectedResult 변수를 이용하여 설정합니다.

그 다음, 비동기적인 작업을 수행하기 위해 Task를 사용합니다.

MKDirections 객체를 생성하고, 이를 이용하여 directions.calculate()를 호출합니다.

경로 계산이 완료되면, 응답 결과에서 첫 번째 경로를 가져와 route 변수에 저장합니다.

이렇게 설정된 getDirections() 함수는 현재 위치와 목적지를 기반으로 경로를 계산하고, 결과를 route 변수에 저장합니다. 이를 통해 경로 안내 기능을 구현할 수 있습니다.

if let route {
                MapPolyline(route)
                    .stroke(.blue, lineWidth: 5)
            }

그 다음 해당 route에는 현 위치에서 선택한 Marker 위치 값의 거리를 계산한 값이 있기 때문에

MapPolyline를 통하여 경로를 표시 할 수 있습니다.

MapPolyline은 지도 위에 선을 그리기 위한 SwiftUI View입니다. 이를 사용하여 경로를 시각적으로 표시할 수 있습니다.

MapPolyline은 Polyline 데이터와 선의 스타일을 인자로 받아 지도 위에 선을 그립니다.

Polyline은 경로를 나타내는 좌표의 집합입니다.

주어진 코드에서는 MapPolyline을 사용하여 route 변수에 저장된 경로를 표시합니다. 경로의 좌표는 Polyline 데이터로 전달되며, 선의 스타일은 파란색으로 설정되고 두께는 5로 설정됩니다.

결과적으로, MapPolyline을 사용하여 경로를 시각적으로 표시할 수 있으며, 이를 통해 사용자에게 명확한 경로 안내를 제공할 수 있습니다.

사용자가 바라보고 있는 지도 화면을 기준으로 주차장, 병원을 찾아보자

//
//  BeantownButtonView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

struct BeanTownButtons: View {
    
    @Binding var position: MapCameraPosition
    @Binding var searchResults: [MKMapItem]
    var visibleRegion: MKCoordinateRegion? //   사용자에게 표시되는 지역 내에서 검색되도록 BeantownButton을 업데이트
    
    .
    .
    .

    
    func search(for query: String) {
        let request = MKLocalSearch.Request()
        request.naturalLanguageQuery = query
        request.resultTypes = .pointOfInterest
        
        //   
        request.region = visibleRegion ?? MKCoordinateRegion(
            center: .lotteTower,
            span: MKCoordinateSpan (latitudeDelta: 0.0125, longitudeDelta: 0.0125)
            )

        Task {
            let search = MKLocalSearch(request: request)
            let response = try? await search.start()
            searchResults = response?.mapItems ?? []
        }
    }

}

코드설명

request.region = visibleRegion ?? MKCoordinateRegion(
    center: .lotteTower,
    span: MKCoordinateSpan(latitudeDelta: 0.0125, longitudeDelta: 0.0125)
)

요약하면 사용자가 바라보는 지도의 영역 값을 가지고 검색하는데 해당 값이 없으면
롯데타워 주변으로 주차장, 병원을 찾겠다는 것입니다.

상세설명

여기서 request.region은 visibleRegion을 기반으로 설정되고 있습니다.

이는 지도 관련 기능에서 검색을 위한 지리적 영역을 제공하려는 일반적인 패턴입니다.

visibleRegion은 옵셔널한 MKCoordinateRegion으로, nil일 수 있습니다. 만약 visibleRegion이 nil이 아니면, 그것을 request.region의 값으로 사용합니다. 만약 visibleRegion이 nil이라면(즉, 제공되지 않았거나 nil인 경우), 기본 지역이 설정됩니다.

기본 지역은 특정 중심 위치 및 지역 크기로 정의된 MKCoordinateRegion입니다.
지역의 중심은 미리 정의된 위치 .lotteTower로 설정됩니다. 지역의 크기는 MKCoordinateSpan을 사용하여 latitudeDelta 및 longitudeDelta가 각각 0.0125로 설정됩니다. latitudeDelta 및 longitudeDelta는 지역의 너비와 높이 또는 "줌" 레벨을 결정하는 데 사용되는 값으로 각각 위도와 경도의 각도입니다.

요약하면, 이 코드는 로컬 검색 요청의 지역을 visibleRegion이 제공되었는지 여부에 따라 설정합니다. 제공되면 해당 지역을 사용하고, 그렇지 않으면 .lotteTower 주변의 특정 줌 레벨을 사용하는 기본 지역을 설정합니다.

MapKit with SwiftUI 기초부터 심화까지 1 : MapKit 다루기 기본 과정

개발자 aloe — Mon, 8 Jan 2024 22:35:50 +0900

https://developer.apple.com/videos/play/wwdc2023/10043/

Meet MapKit for SwiftUI - WWDC23 - Videos - Apple Developer

Discover how expanded SwiftUI support for MapKit has made it easier than ever for you to integrate Maps into your app. We'll show you how...

developer.apple.com

https://laurentbrusa.hashnode.dev/summarising-meet-mapkit-for-swiftui-from-wwdc23

Summarising "Meet MapKit for SwiftUI" from WWDC23

Summarising "Meet MapKit for SwiftUI" from WWDC23 tldr a collection of notes and screenshots

laurentbrusa.hashnode.dev

위에 분이 상세하게 정리를 잘 해주셨습니다. 한번 보고오시는 것도 괜찮습니다

저는 해당 내용을 한국 버전으로 설명해보겠습니다!!!!

Map을 지도에 표시해보자!!!

import SwiftUI
import MapKit

struct ContentView: View {
    var body: some View {
        Map ()
    }
}

끝 엄청 쉽습니다!!!!

지도의 Marker를 표시해보자!

extension CLLocationCoordinate2D {
    static let lotteTower = CLLocationCoordinate2D(latitude: 37.5125, longitude: 127.102778)
}

struct ContentView: View {
    var body: some View {
        Map() {
            Marker("lotteTower", coordinate: .lotteTower)
        }
    }
}

롯데타워를 찍어볼 거예요!!!
기본적으로 Marker를 하나 찍는다면 지도가 켜질 때 마커를 찍은 곳으로 카메라의 초점이 맞춰집니다.

CLLocationCoordinate2D 은 Core Location 프레임워크에서 제공되는 구조체로, 지리적인 위치를 나타내는 데 사용됩니다. 이 구조체는 위도(latitude)와 경도(longitude)의 두 속성을 가지며, 지구상의 특정 지점을 나타냅니다.

Marker는 기본적으로 LLocationCoordinate2D 값을 가져요. 어디인지 알아야 찍어주겠죠??

커스텀 Marker를 만들어보자

Marker는 기본적인 pin의 View를 보여주지만, Annotation을 사용하면 커스텀을 통해 보여주고 싶은 pin을 찍을 수 있어요.

//
//  ContentView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

extension CLLocationCoordinate2D {
    static let lotteTower = CLLocationCoordinate2D(latitude: 37.5125, longitude: 127.102778)
}

struct ContentView: View {
    var body: some View {
        Map() {
            Annotation("lotteTower", coordinate: .lotteTower) {
                ZStack {
                    RoundedRectangle(cornerRadius: 5)
                        .fill(.background)
                    RoundedRectangle(cornerRadius: 5)
                        .stroke(.secondary, lineWidth: 5)
                    Image(systemName: "house.circle.fill")
                        .padding(5)
                }
            }
            .annotationTitles(.hidden) // 제목 감추기
        }
    }
}


#Preview {
    ContentView()
}

mapStyle을 알아보자!!!!

apple은 다양한 MapStyle을 제공해 주고 있습니다.
지금 저희가 보고 있는 지도의 style은

.mapStyle(.standard)

이것이 표준 지도 스타일입니다. 기본적으로 실제 종이 지도와 매우 유사한 평면 프레젠테이션을 제공합니다.

.mapStyle(.imagery(elevation: .realistic))

해당 스타일은 위성 사진을 이용하여 지도를 표시합니다.

.mapStyle(.hybrid(elevation: .realistic))

하이브리드 지도 스타일은 다양한 도로 표지판까지 보여줍니다.

심화 과정 1 : 찾고 싶은 장소를 찾아봅시다!!! ex (주차장, 병원)

지도에서 롯데타워 근처 주차장, 병원을 찾아볼 거예요
따라오시는 여러분은 다른 장소를 찾아서 확인해 보세요!!!!
조금이라고 응용해 봐야 자기 것이 됩니다!!! ㅎㅎ

MKLocalSearch를 사용하여 lotteTower 근처의 특정 장소를 찾아보겠습니다.

우선 검색 버튼을 만들어 보겠습니다

//
//  BeantownButtonView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

struct BeanTownButtons: View {
    
    @Binding var searchResults: [MKMapItem]
    
    var body: some View {
        HStack {
            Button {
                search(for: "parking")
            } label: {
                Label("parking lot", systemImage: "car")
            }
            .buttonStyle(.borderedProminent)
            
            Button {
                search(for: "hospital")
            } label: {
                Label("restroom", systemImage: "cross.case")
            }
            .buttonStyle(.borderedProminent)
        }
        .labelStyle(.iconOnly)
    }
    

    func search(for query: String) {
        let request = MKLocalSearch.Request()
        request.naturalLanguageQuery = query
        request.resultTypes = .pointOfInterest
        request.region = MKCoordinateRegion(
            center: .lotteTower,
            span: MKCoordinateSpan (latitudeDelta: 0.0125, longitudeDelta: 0.0125)
            )

        Task {
            let search = MKLocalSearch(request: request)
            let response = try? await search.start()
            searchResults = response?.mapItems ?? []
        }
    }

}

중점적으로 봐야할 부분은 search함수 내부 코드 입니다.

func search(for query: String) {
    // MKLocalSearch의 Request를 생성하여 검색 조건을 설정합니다.
    let request = MKLocalSearch.Request()
    // 검색할 키워드를 설정합니다.
    request.naturalLanguageQuery = query
    // 검색 결과의 타입을 관심 지점(POI)으로 설정합니다.
    request.resultTypes = .pointOfInterest
    
    // 검색을 수행할 지역을 설정합니다. 여기서는 .lotteTower 위치 주변으로 설정합니다.
    request.region = MKCoordinateRegion(
        center: .lotteTower,
        span: MKCoordinateSpan(latitudeDelta: 0.0125, longitudeDelta: 0.0125)
    )

    // 비동기 함수로서의 Task를 사용하여 검색을 시작합니다.
    Task {
        // MKLocalSearch 객체를 생성합니다.
        let search = MKLocalSearch(request: request)
        
        // 검색을 비동기로 실행하고 결과를 받아옵니다.
        let response = try? await search.start()
        
        // 검색 결과를 searchResults에 업데이트합니다.
        searchResults = response?.mapItems ?? []
    }
}

쉽게 설명하면 버튼을 누르면 롯데타워 근처 주차장과 병원이 검색됩니다.

MKLocalSearch.Request(): MKLocalSearch.Request()는 MapKit에서 제공하는 지역 검색 요청 객체를 생성하는 메서드입니다. 이 객체를 사용하여 검색에 필요한 매개변수를 설정할 수 있습니다.

쉽게 설명하면 버튼을 누르면 롯데타워 근처 주차장과 병원이 검색됩니다.

예를 들어, 검색할 키워드, 검색 결과의 타입, 검색을 수행할 지역 등을 설정할 수 있습니다.
애플이 만든 거라 그냥 이용해서 사용하면 됩니다. 하하 항상 쉽게 쉽게 생각하고 사용합시다

request.resultTypes = .pointOfInterest: 이 부분은 생성한 MKLocalSearch.Request 객체에 대한 설정 중 하나입니다. resultTypes 속성은 검색 결과의 타입을 나타내며, 여기서는 .pointOfInterest로 설정되어 있습니다.

이는 관심 지점(POI)을 의미하며, 주변의 특정 지점들에 대한 정보를 검색하고자 할 때 사용됩니다.

예를 들면 레스토랑, 상점, 공원 등이 관심 지점에 해당합니다. 즉 검색을 하는데 추가적인 정보를 넣어준다고 생각하면 됩니다.

MKCoordinateRegion: MKCoordinateRegion은 지도에서 특정 지역을 표현하는 데 사용되는 객체입니다. 매개변수로 받는 것은 중심 좌표(center)와 지도 영역의 스팬(span)입니다.

center: .lotteTower: 중심 좌표를 설정합니다. 여기서는 정적으로 정의된 CLLocationCoordinate2D.lotteTower를 사용하여 Lotte Tower의 좌표를 중심으로 설정하고 있습니다.
span: MKCoordinateSpan(latitudeDelta: 0.0125, longitudeDelta: 0.0125): 지도의 스팬을 설정합니다.
latitudeDelta와 longitudeDelta는 각각 위도 및 경도의 변화를 나타냅니다.
이를 조절하여 지도의 확대 수준을 조절할 수 있습니다. 작은 값은 더 큰 확대 수준을 의미합니다.

쉽게 롯데타워 주변(위도, 경도 값을 이용하여)으로 검색 결과를 찾아서 넣어주겠다는 이야기입니다.

searchResults = response?.mapItems ?? []

MKMapItem 이 뭔가요 ?

MKMapItem은 MapKit 프레임워크에서 제공되는 클래스로, 지도 위의 특정 지점이나 장소를 나타냅니다.

MKMapItem은 주로 지도 검색 결과를 나타내거나, 특정 위치에 대한 정보를 표현하는 데 사용됩니다.

MKMapItem의 인스턴스는 일반적으로 MKLocalSearch를 사용하여 수행된 지역 검색의 결과로 반환됩니다.

각 MKMapItem은 특정 위치에 대한 정보를 가지고 있으며, 이 정보에는 위치의 이름, 주소, 좌표 등이 포함될 수 있습니다.

여러 MKMapItem을 배열로 관리하면, 지도 상에 여러 장소를 표시하거나 검색 결과를 나타낼 수 있습니다.

각 MKMapItem은 지도에 표시되는 항목의 기본 데이터를 캡슐화합니다.

예를 들어, MKMapItem을 사용하여 레스토랑, 호텔, 상점 등의 장소에 대한 정보를 가져와서 지도에 표시하거나 해당 장소로 길 안내 등의 작업을 수행할 수 있습니다.

검색 결과를 뿌려보자!!!

//
//  ContentView.swift
//  MapKitStudy
//
//  Created by 정정욱 on 1/7/24.
//

import SwiftUI
import MapKit

extension CLLocationCoordinate2D {
    static let lotteTower = CLLocationCoordinate2D(latitude: 37.5125, longitude: 127.102778)
}

struct ContentView: View {
    
    /*   검색결과를 담을 배열
      MKLocalSearch와 같은 MapKit API가 장소를 표시할 때 사용하는 MKMapItem임
      MKMapItem로 작업하면 Marker가 콘텐츠와 형식을 자동으로 지원해 무척 유용함
      */
     @State private var searchResults: [MKMapItem] = []
    
    var body: some View {
        Map() {
            Annotation("lotteTower", coordinate: .lotteTower) {
                ZStack {
                    RoundedRectangle(cornerRadius: 5)
                        .fill(.background)
                    RoundedRectangle(cornerRadius: 5)
                        .stroke(.secondary, lineWidth: 5)
                    Image(systemName: "house.circle.fill")
                        .padding(5)
                }
            }
            .annotationTitles(.hidden) // 제목 감추기
            
            //   검색 결과 마커 추가
            ForEach(searchResults, id: \.self) { result in
                Marker(item: result)
								// 결과가 MKMapItem type이였는데 
								// MKMapItem로 작업하면 Marker가 콘텐츠와 형식을 자동으로 지원해서 넣어주기만 하면 끝이에요
            }
        }
        .mapStyle(.standard)
        .safeAreaInset(edge: .bottom) {
            HStack {
                Spacer()
						//   바인딩이 되어 있어서 버튼을 누르면 바로바로 결과를 확인 할 수 있어요
                BeanTownButtons(searchResults: $searchResults)
                    .padding(.top)
                Spacer()
            }
            .background(.ultraThinMaterial)
        }

    }
}


#Preview {
    ContentView()
}

iOS 주니어 개발자의 2023년도를 돌아보며 회고

개발자 aloe — Mon, 8 Jan 2024 17:27:40 +0900

안녕하세요. 오랜만에 인사드립니다... aloe입니다.

블로그 포스팅을 꽤 오랫동안 쉬었습니다.. 정말 바쁜 2023년도를 보냈었는데
네 맞습니다 핑계입니다.. 다시 열심히 달려보려고 합니다.

두서없이 적었지만, 부족한 저의 글을 읽어 주실 분들에게 미리 감사드립니다.
누구에게 말하는 게 아닌 일기체로 작성하였습니다. 편하게 봐주셨으면 좋겠습니다.
블로그 포스팅을 자주 올리지는 못했지만. 많이 배우고 성장했던, 어느 분야의 개발자로 나아갈지 정했던 한 해였습니다.

2023년도를 돌아보며

학업적인 측면에서 잘한점

나는 컴퓨터 소프트웨어학과에 다니며 꽤 열심히 대학 생활을 했다.
20살 때 대학에 입학한 후로 목표는 하나였다. 돈 내고 학교 다니지 않기…. 수석으로 졸업해보기...

살면서 한 번도 1등을 해보지 못했기 때문에 막연하게 한 번이라도 해보자고 생각했던 거 같다.
운 좋게도 현재 그 목표는 이루면서 살고 있다. 수업이 재미있었다기보단. 배우고 싶은 학문이었고.
반 오십이 된 2024년도 기준으로 나의 가장 큰 장점이 성실함아닐지 생각해 본다..
머리가 좋은 편도 아니고 그냥 목표가 생기면 꾸준하게 나아가며 최고의 성과를 내려고 고민하는 게 내 장점이라고 생각한다.

그래서 아무튼 결과로써 성실함을 보여줄 수 있는 지표 하나를 완성하고 있다는 게 2023년도에 잘한 점이라고 생각한다.

학업적인 측면에서 부족했던점

컴퓨터공학, 소프트웨어학과 등등 개발자로 취업하는데 있어 전공자라는 타이틀을 달수는 있는 학과들이 있다.

나 역시 위에서 언급한 대로 해당 학부 생활을 꽤 열심히 했지만 해당 학과의 교과목을 잘한다고 좋은 개발자가 될 수 있나?,

좋은 회사에 취업할 수 있나? 이건 또 다른 이야기라고 생각한다. 물론 필요한 역량들은 맞다..

내가 하고 싶은 말은 취업을 하기 위한 공부 방법, 계획과 학점을 잘 받기 위한 공부 방법, 계획은 다르게 설계 해야 맞는다고 보는 것이다.
암튼 본론으로 다시 돌아와서

나의 학부 시절을 돌이켜보면 전공자 타이틀을 얻을 수 있는 학과들에서 얻을 수 있는 가장 큰 장점을 누리지 못했다. 해당 학부에서 얻을 수 있는 장점을 나열하면

소프트웨어 개발에 대한 전반적인 영역 찍먹 가능
선 후배 간 교류 가능
CS 지식 학습 가능

뭐 크게 이 정도인 거 같다. 하지만 나는 너무 학점을 따는 데만 몰두 했었고 학부 친구, 선, 후배들과 코로나를 거치며 협업 개발,

스터디 등등 실질적인 개발을많이 못 해본 거 같다. 그래서 두려움이 컸다.

이대로 가다간 취업 시작에서 저 개발자인데요. 이력은 졸업장 밖에 없습니다…ㅎㅎ를 외치고 바로 탈락 +외면당할 게 뻔했으니까……

나는 뭘 개발할 수 있고, 뭘 잘하는 사람이지? 어떻게 어느 분야로 취업하지?

흠 일단 전공자 타이틀 학과(컴퓨터공학, 소프트웨어학과 등등)를 다니는 학부생들 80%는 이 생각을 하는 거 같다.

개발자는 개발을 하는 사람 즉 뭔가를 만드는 사람인데 전공지식이 개발을 하는데 도움을 줄 수 있지만 정작 뭔가를 만들 줄 모르는사람이라는 걸 깨달은 것이다. 그리하여 어느 분야를 깊게 공부(개발)를 해볼까? 하다가 어릴 때부터 아이폰만을 사용했고 애플을 좋아하기도 해서 맥북을 구매한 다음 iOS 개발을 본격적으로 하기 시작했다.

이전까지 6개월 동안 Flutter를 이용하여 앱 출시까지 하고 공모전도 나가보았기에 앱 쪽은 알 수 없는 근거 없는 자신감 ... 진입장벽이 낮다고 생각했다. (오만했다 매우 오만했다.)

iOS 개발 시작.

2023년도 1월부터 iOS 개발을 제대로 시작했다.
인생 첫 부트캠프 설레는 마음으로 공부를 시작했고 Swift 문법에 대하여 깊게 학습하고 UIKit으로 많은 앱을 만들어보며

실력을 향상할 수 있었다. 사실 말이 2개월 과정이지 앱 만들기 과정 그리고 복습을 포함하면 5개월 과정인 거 같다.

정말 재미있게 공부 했던 거 같다. 힘들긴 했지만, 덕분에 iOS 개발을 하는 좋은 동료들 또한 만날 수 있었다.

칼리, 미뉴, 코지 등등

부트캠프에서 잘한 점

아무래도 Swift 문법을 깊게 배우고, iOS 관련 지식과 나 이제 개발을 할 수 있다는 자신감을 얻을 수있었던 거거 같다.

이대로열심히 하면면 지성이면 감천이라고 취업에 길이 열리지 않을까?

근데 뭐 사실 취업도 취업이지만 에초에 해당 전공을 하게 된 이유가 머릿속에 생각나는 아이디어들을 바로바로 만들어

서비스를 해보고 싶었기 선택했던 거라 이제는 마음만 먹으면 구현할 수 있겠다는 자신감을 얻게 된 게 가장 크다고 생각한다.

출처 : https://maily.so/mindbook/posts/7a231d31

(그래서 생각난 아이디어를 구현해 앱까지 출시했다…. 추후 회고 예정)

부트캠프에서 부족했던점

돌이켜보면 부족했던 점은 잘못된 공부 방법인 거 같다.
인터넷 강의는 좋고 질 좋은 정보를 제공한다. 하지만 내 것으로 만들기 위해 체득하는 과정이 필요하다고 느꼈다.

물론 기록을 노선에다가 하나하나 잘 정리하고 1일 1커밋 하면서 정리를 나름 하긴 했지만

개발 또한 영어, 불어 등등 마찬가지로 일단 Swift라는 언어를 배웠다면 실제로 써봐야 완전히 내 것이 된다는 걸 알았다.
나는 당시 다 외운다는 마인드로 접근하고 공부를 했다.

이것도 주관적인 생각이지만 어차피 개발을 하는 데 있어서 다 외울 수 없다. 부트캠프를 진행하면서 내가 했던 바보 같은 방법이다.

정말 다 외우려고 했다… 조금만 또다시 복습하지 않으면 까먹는 것을…

(내가 바보라 그런 걸 수 있다, 다양한 지식, 많은 정보… 개인마다 뇌라는 휘발성 메모리에 수용할 수 있는 양은 다르다고 생각한다)

그래서 많은 개발 학도들이 GitHub이라는 비휘발성 메모리 즉 실제 영구적인 저장장소에 저장하며 기록하는 거 같다.
블로그 포스팅도 마찬가지고…

그래서 바보 같은 실수를 한번 하고 공부 방법을 바꾼 게 기록하되 그 기록을 보고 다시 머릿속에서 끄집어낼 수 있을 정도로 설명하여

커밋을 남기거나 주석을 다는 것이었다.

요약 다 외우려말자, 필수적인 건 외우더라도 나중에 봤을 때 이해할 수 있게 설명해서 정리해 두자.

개선할 점

블로그 포스팅을 열심히 하자 그리고 글을 좀 더 잘 쓰도록 노력하자…

노션에 정리를 하거나 코드에 폭풍 주석을 때려 넣어서 그런지 나중에 봤을 때 이해할 수는 있지만 시간이 너무 많이 들었다.

해당 개념을 이해하고 있을 때는 글을 좀 대충 적는? 아무튼 그런 경향이 있는 거 같다.

2개월 3개월 뒤에 돌아왔을 때는 다시 모르는 사람에게 설명하듯이 글을 써 기록을 남기는 게 중요 한 거 같다.
그렇지 않으면 읽기 힘들고 애써 작성한 코드, 글들이 하나의 레거시 덩어리가 되어버려서 영영 보지 않게 될 수 있다.

그리하여 2024 목표는 블로그 포스팅이다.

인기 있는 블로그는 바라지도 않지만 내가 투자한 1시간~3시간의 포스팅이 3개월 뒤에 나에게, 혹은 다른 사람들의 시간을 5시간씩 절약한다고 했을 때 기대효과는 어마어마하다고 생각한다. 열심히 하자

클론코딩에 대하여

부트캠프가 끝난 후 포트폴리오용으로 추천받은 강의가 Twitter 클론 코딩 강의였다.

1개월 반 정도 들었던 거 같은데
클론 코딩을 하며 느낀 점이다. 클론 코딩의 장점은 해당 로직을 어떻게 구현할 수 있는지 볼 수 있다는 것이다.
여기서 포인트는 “단지 볼 수 있다는 것”..

클론 코딩강의를 들으면 나도 이런 서비스쯤은 이제 바로 만들 수 있겠다!! 라는 생각을 했었는데 (오만했다 매우 오만했다.)

장점이라고 생각하는 점

일단 현재 출시된 유명한 앱을 따라 만들어 보며 어떻게 구현하였는지 똑같지는 않겠지만 대략 이해할 수 있었다.

최근 육각형 개발자라는 책을 읽었는데 좋은 글이 있었다.
“개발은 코드를 짜는 거뿐만 아니라 서비스를 설계하고, 출시 했다면 유지보수 등등 이 일련의 과정 전체가 개발이라는 것”

이게 클론 코딩에서 얻는 가장 큰 장점이라고 생각한다. 설계 단계부터 구현 단계까지 공부할 수 있다.

그런 의미에서 보면 많이 배웠던 거 같다. MVVM 패턴을 활용하여 UIKit으로 어떻게 프로젝트를 하는지, 또는 설계할 수 있는지,

Firebase는 어떻게 사용할 수 있는지 등등 다만 부트캠프에서 했던 실수를 반복하고 싶지는 않아서

구현 로직을 외우지는 않고 참고 정도로 기록만 해두었다.

(어떤 순서로 구현했는지, 어떻게 리팩토링했는지 중점 개념과 포인트 위주로 기록하였다.)

단점, 개선할점

내 것이 아니다.
가장 크게 느낀 게 클론 코딩은 개발자로 살아가는 데 있어 자력이 사라지는 거 같다.

즉 뭔가를 만들어야 할 때

비슷한 클론 코딩 강의가 있는지 찾는다.
강의를 구매해서 강의를 다 듣는다.
내가 만들고 싶은 서비스를 구현한다.

물론 이것 또한 개발하는 하나의 과정이라고 볼 수 있다. 당시 나처럼 뭘 개발해야 할지 모르겠고, 아이디어는 있지만 어떻게 개발할지

감이 안 올 때, 초심자의 입장에서는 클론 코딩을 추천한다. 하지만 이게반복되면 안 될 거 같다.. 위에 언급한 로직은 내가 이후에 한 실수다. 단지 따로 시간 내서 공부하는 게 귀찮고, 몸도 마음도 편하니까…

클론 코딩을 또 들을지는 모르겠지만 (나중에 정말 필요하다면 듣겠지만)

내가 생각하는 클론 코딩 == “가이드라인을 알려줬으니 이제 네가 생각하는 걸 만들어~”

이렇게 접근하는 게 맞는 거 같다. 클론 코딩을 듣더라도 여기서 끝내지 말고 내 것을 만들어보자.

또 한번의 부트캠프 멋쟁이사자(테킷 앱 스쿨 : iOS 3기)

앨런 부트캠프는 iOS 개발 기준으로 Swift 문법과 UIKit 프레임워크를 활용한 개발에 대하여 초점을 맞춰 알려줬다.

하지만 SwiftUI는 따로 배워야 했고. 이글의 서두에서 언급했듯이 필요하다고 느꼈던 협업 개발을 해보지 못했다.

그래서 SwiftUI를 배워보고 싶었고 협업 개발을 해보고 싶어서 멋쟁이 사자(테킷 앱 스쿨 : iOS 3기 ) 지원했다. 아무튼… 합격했다.

여담으로 당시 apple 디벨로퍼 아카데미에도 지원하였는데 하반기 모집에서 떨어졌고 상반기 모집에서 바보 같이 코로나에 걸려 드러눕는 바람에 테스트를 응시조차 하지 못했다. (열심히 라이프 저니 작성도 했는데) 근데 이것 또한 운명이라 생각하고 받아들였다.

잘한 점, 장점 ing

SwiftUI로 개발하는 것이 익숙해졌다. 사실 과정을 진행하면서 SwiftUI를 따로 더 학습해서 그런 것도 있는 거 같다. 그리고 그토록 해보고 싶던 협업 프로젝트를 한 번 정도 진행하였는데 git 컨벤션, git Flow 전략, 노션을 통한 워크스페이스 관리, 기획 단계의 MVP 설계 등등 여러 개발자가 공통의 목표(프로젝트)를 위해 협업 개발을 어떻게 할 수 있는지, 어떻게 효율적으로 작업 할 수 있는지를 알아갈 수 있었다. 같은 팀에 현업에서 개발하다 오신 분이 3분이나 있어서 특별한 경험을 했던 거 같다. 많이 배웠습니다. 정말 ㅠㅠ 아무튼 그렇게 첫 프로젝트를 마무리했다. 1주일이라는 시간밖에 없어서 너무 급하게 했지만, 충분히 보람 있었다.

https://github.com/APP-iOS3rd/PJ2T1_WeatherPlaylist

부족한 점, 개선할 점 ing

기술적으로 내가 부족하다는 게 많다는 걸 느꼈다. 그리고 git이 완벽하게 익숙하지 않다 보니 branch를 merge하는 과정에서

conflict가 많이 일어났고, 코드 리뷰를 겪어보며 내 코드가 얼마나 지저분하고 스파게티 코드인지 알 수 있었다.

코드 리뷰… 받는 것, 하는 것 둘 다 아직 필자가 아주 부족해서 시험시간 5분 전처럼 떨리는 마음으로 임하고 있다.

그렇지만 조금 더 자주 해야 할 거 같다. 배우는 게 정말 너무 많은 시간인 거 같다.

추후에 최적화에 대하여 학습해 보고 Clean Architecture를 꼭 한번 읽어봐야겠다.

이 경험 덕분에 현재는 짬짬이 Clean Code라는 책을 읽게 되었다.

멋사가 끝나면 전체적인 회고를 한 번 더 해서 포스팅하겠다.

다음 회고 이야기

드디어 내 것을 만들다, 앱 출시 회고

Google Career Certificates 프로그램 선발, 후기

Memoir Mate 개인정보처리방침

개발자 aloe — Tue, 19 Dec 2023 16:52:33 +0900

< Memoir Mate>('https://aloe-study.tistory.com/'이하 'aloe 기술 블로그')은(는) 「개인정보 보호법」 제30조에 따라 정보주체의 개인정보를 보호하고 이와 관련한 고충을 신속하고 원활하게 처리할 수 있도록 하기 위하여 다음과 같이 개인정보 처리방침을 수립·공개합니다.

○ 이 개인정보처리방침은 2023년 12월 19부터 적용됩니다.

제1조(개인정보의 처리 목적)

< Memoir Mate >('https://aloe-study.tistory.com/'이하 'aloe 기술 블로그')은(는) 다음의 목적을 위하여 개인정보를 처리합니다. 처리하고 있는 개인정보는 다음의 목적 이외의 용도로는 이용되지 않으며 이용 목적이 변경되는 경우에는 「개인정보 보호법」 제18조에 따라 별도의 동의를 받는 등 필요한 조치를 이행할 예정입니다.

제2조(개인정보의 처리 및 보유 기간)

① < Memoir Mate >은(는) 법령에 따른 개인정보 보유·이용기간 또는 정보주체로부터 개인정보를 수집 시에 동의받은 개인정보 보유·이용기간 내에서 개인정보를 처리·보유합니다.

② 각각의 개인정보 처리 및 보유 기간은 다음과 같습니다.

1.<홈페이지 회원가입 및 관리>
<홈페이지 회원가입 및 관리>와 관련한 개인정보는 수집.이용에 관한 동의일로부터<없음>까지 위 이용목적을 위하여 보유.이용됩니다.
보유근거 : 없음
관련법령 :
예외사유 : 없음

제3조(처리하는 개인정보의 항목)

① < Memoir Mate >은(는) 다음의 개인정보 항목을 처리하고 있습니다.

1< 홈페이지 회원가입 및 관리 >
필수항목 : Email, 이름
선택항목 : 없음

제4조(개인정보의 파기절차 및 파기방법)

① < Memoir Mate > 은(는) 개인정보 보유기간의 경과, 처리목적 달성 등 개인정보가 불필요하게 되었을 때에는 지체없이 해당 개인정보를 파기합니다.

② 정보주체로부터 동의받은 개인정보 보유기간이 경과하거나 처리목적이 달성되었음에도 불구하고 다른 법령에 따라 개인정보를 계속 보존하여야 하는 경우에는, 해당 개인정보를 별도의 데이터베이스(DB)로 옮기거나 보관장소를 달리하여 보존합니다.
1. 법령 근거 :
2. 보존하는 개인정보 항목 : 계좌정보, 거래날짜

③ 개인정보 파기의 절차 및 방법은 다음과 같습니다.
1. 파기절차
< Memoir Mate > 은(는) 파기 사유가 발생한 개인정보를 선정하고, < 우기 > 의 개인정보 보호책임자의 승인을 받아 개인정보를 파기합니다.

2. 파기방법

제5조(정보주체와 법정대리인의 권리·의무 및 그 행사방법에 관한 사항)

① 정보주체는 Memoir Mate에 대해 언제든지 개인정보 열람·정정·삭제·처리정지 요구 등의 권리를 행사할 수 있습니다.

② 제1항에 따른 권리 행사는Memoir Mate에 대해 「개인정보 보호법」 시행령 제41조제1항에 따라 서면, 전자우편, 모사전송(FAX) 등을 통하여 하실 수 있으며 우기은(는) 이에 대해 지체 없이 조치하겠습니다.

③ 제1항에 따른 권리 행사는 정보주체의 법정대리인이나 위임을 받은 자 등 대리인을 통하여 하실 수 있습니다.이 경우 “개인정보 처리 방법에 관한 고시(제2020-7호)” 별지 제11호 서식에 따른 위임장을 제출하셔야 합니다.

④ 개인정보 열람 및 처리정지 요구는 「개인정보 보호법」 제35조 제4항, 제37조 제2항에 의하여 정보주체의 권리가 제한 될 수 있습니다.

⑤ 개인정보의 정정 및 삭제 요구는 다른 법령에서 그 개인정보가 수집 대상으로 명시되어 있는 경우에는 그 삭제를 요구할 수 없습니다.

⑥ Memoir Mate은(는) 정보주체 권리에 따른 열람의 요구, 정정·삭제의 요구, 처리정지의 요구 시 열람 등 요구를 한 자가 본인이거나 정당한 대리인인지를 확인합니다.

제6조(개인정보의 안전성 확보조치에 관한 사항)

< Memoir Mate >은(는) 개인정보의 안전성 확보를 위해 다음과 같은 조치를 취하고 있습니다.

1. 정기적인 자체 감사 실시
개인정보 취급 관련 안정성 확보를 위해 정기적(분기 1회)으로 자체 감사를 실시하고 있습니다.

제7조(개인정보를 자동으로 수집하는 장치의 설치·운영 및 그 거부에 관한 사항)

Memoir Mate 은(는) 정보주체의 이용정보를 저장하고 수시로 불러오는 ‘쿠키(cookie)’를 사용하지 않습니다.

제8조(행태정보의 수집·이용·제공 및 거부 등에 관한 사항)

행태정보의 수집·이용·제공 및 거부등에 관한 사항

<개인정보처리자명>은(는) 온라인 맞춤형 광고 등을 위한 행태정보를 수집·이용·제공하지 않습니다.

제9조(추가적인 이용·제공 판단기준)

< Memoir Mate > 은(는) ｢개인정보 보호법｣ 제15조제3항 및 제17조제4항에 따라 ｢개인정보 보호법 시행령｣ 제14조의2에 따른 사항을 고려하여 정보주체의 동의 없이 개인정보를 추가적으로 이용·제공할 수 있습니다.
이에 따라 < Memoir Mate > 가(이) 정보주체의 동의 없이 추가적인 이용·제공을 하기 위해서 다음과 같은 사항을 고려하였습니다.
▶ 개인정보를 추가적으로 이용·제공하려는 목적이 당초 수집 목적과 관련성이 있는지 여부

▶ 개인정보를 수집한 정황 또는 처리 관행에 비추어 볼 때 추가적인 이용·제공에 대한 예측 가능성이 있는지 여부

▶ 개인정보의 추가적인 이용·제공이 정보주체의 이익을 부당하게 침해하는지 여부

▶ 가명처리 또는 암호화 등 안전성 확보에 필요한 조치를 하였는지 여부

※ 추가적인 이용·제공 시 고려사항에 대한 판단기준은 사업자/단체 스스로 자율적으로 판단하여 작성·공개함

제10조(가명정보를 처리하는 경우 가명정보 처리에 관한 사항)

< Memoir Mate > 은(는) 다음과 같은 목적으로 가명정보를 처리하고 있습니다.

▶ 가명정보의 처리 목적

- 직접작성 가능합니다.

▶ 가명정보의 처리 및 보유기간

- 직접작성 가능합니다.

▶ 가명정보의 제3자 제공에 관한 사항(해당되는 경우에만 작성)

- 직접작성 가능합니다.

▶ 가명정보 처리의 위탁에 관한 사항(해당되는 경우에만 작성)

- 직접작성 가능합니다.

▶ 가명처리하는 개인정보의 항목

- 직접작성 가능합니다.

▶ 법 제28조의4(가명정보에 대한 안전조치 의무 등)에 따른 가명정보의 안전성 확보조치에 관한 사항

- 직접작성 가능합니다.

제11조 (개인정보 보호책임자에 관한 사항)

① Memoir Mate 은(는) 개인정보 처리에 관한 업무를 총괄해서 책임지고, 개인정보 처리와 관련한 정보주체의 불만처리 및 피해구제 등을 위하여 아래와 같이 개인정보 보호책임자를 지정하고 있습니다.

▶ 개인정보 보호책임자
성명 :정정욱
직책 :대표
직급 :CEO
연락처 :01073392128, jeonguk29@naver.com,

※ 개인정보 보호 담당부서로 연결됩니다.

▶ 개인정보 보호 담당부서
부서명 :
담당자 :
연락처 :, ,

② 정보주체께서는 Memoir Mate 의 서비스(또는 사업)을 이용하시면서 발생한 모든 개인정보 보호 관련 문의, 불만처리, 피해구제 등에 관한 사항을 개인정보 보호책임자 및 담당부서로 문의하실 수 있습니다. Memoir Mate 은(는) 정보주체의 문의에 대해 지체 없이 답변 및 처리해드릴 것입니다.

제12조(국내대리인의 지정)

정보주체는 ｢개인정보 보호법｣ 제39조의11에 따라 지정된 < Memoir Mate >의 국내대리인에게 개인정보 관련 고충처리 등의 업무를 위하여 연락을 취할 수 있습니다. < Memoir Mate >은(는) 정보주체의 개인정보 관련 고충처리 등 개인정보 보호책임자의 업무 등을 신속하게 처리할 수 있도록 노력하겠습니다.

▶ < Memoir Mate > 은(는) ｢개인정보 보호법｣ 제39조의11에 따라 국내대리인을 지정하였습니다.

- 국내대리인의 성명 : 정정욱

- 국내대리인의 주소 : 서울 특별시

- 국내대리인의 전화번호 : 01073392128

- 국내대리인의 전자우편 주소 : [대리인 전자우편_직접입력]

제13조(개인정보의 열람청구를 접수·처리하는 부서)
정보주체는 ｢개인정보 보호법｣ 제35조에 따른 개인정보의 열람 청구를 아래의 부서에 할 수 있습니다.
< Memoir Mate >은(는) 정보주체의 개인정보 열람청구가 신속하게 처리되도록 노력하겠습니다.

▶ 개인정보 열람청구 접수·처리 부서
부서명 :
담당자 :
연락처 : , ,

제14조(정보주체의 권익침해에 대한 구제방법)

정보주체는 개인정보침해로 인한 구제를 받기 위하여 개인정보분쟁조정위원회, 한국인터넷진흥원 개인정보침해신고센터 등에 분쟁해결이나 상담 등을 신청할 수 있습니다. 이 밖에 기타 개인정보침해의 신고, 상담에 대하여는 아래의 기관에 문의하시기 바랍니다.

1. 개인정보분쟁조정위원회 : (국번없이) 1833-6972 (www.kopico.go.kr)
2. 개인정보침해신고센터 : (국번없이) 118 (privacy.kisa.or.kr)
3. 대검찰청 : (국번없이) 1301 (www.spo.go.kr)
4. 경찰청 : (국번없이) 182 (ecrm.cyber.go.kr)

「개인정보보호법」제35조(개인정보의 열람), 제36조(개인정보의 정정·삭제), 제37조(개인정보의 처리정지 등)의 규정에 의한 요구에 대 하여 공공기관의 장이 행한 처분 또는 부작위로 인하여 권리 또는 이익의 침해를 받은 자는 행정심판법이 정하는 바에 따라 행정심판을 청구할 수 있습니다.

※ 행정심판에 대해 자세한 사항은 중앙행정심판위원회(www.simpan.go.kr) 홈페이지를 참고하시기 바랍니다.

제15조(영상정보처리기기 운영·관리에 관한 사항)
① < Memoir Mate >은(는) 아래와 같이 영상정보처리기기를 설치·운영하고 있습니다.

1.영상정보처리기기 설치근거·목적 : < Memoir Mate >의

2.설치 대수, 설치 위치, 촬영 범위 :
설치대수 : 대
설치위치 :
촬영범위 :

3.관리책임자, 담당부서 및 영상정보에 대한 접근권한자 :

4.영상정보 촬영시간, 보관기간, 보관장소, 처리방법
촬영시간 : 시간
보관기간 : 촬영시부터
보관장소 및 처리방법 :

5.영상정보 확인 방법 및 장소 :

6.정보주체의 영상정보 열람 등 요구에 대한 조치 : 개인영상정보 열람.존재확인 청구서로 신청하여야 하며, 정보주체 자신이 촬영된 경우 또는 명백히 정보주체의 생명.신체.재산 이익을 위해 필요한 경우에 한해 열람을 허용함

7.영상정보 보호를 위한 기술적.관리적.물리적 조치 :

제16조(개인정보 처리방침 변경)

① 이 개인정보처리방침은 2023년 12월 19부터 적용됩니다.

② 이전의 개인정보 처리방침은 아래에서 확인하실 수 있습니다.

예시 ) - 20XX. X. X ~ 20XX. X. X 적용 (클릭)

영진위 API활용 영잘알 App 완성

개발자 aloe — Thu, 1 Jun 2023 11:46:35 +0900

//
//  ViewController.swift
//  MovieJJK
//
//  Created by comsoft on 2023/05/04.
//

import UIKit

let name = ["1. 가디언즈 오브 갤럭시: Volume 3", "2. 슈퍼 마리오 브라더스", "3. 드림","4. 존 윅 4", "5. 스즈메의 문단속", "6. 옥수역귀신", "7. 리바운드", "8. 더 퍼스트 슬램덩크", "9. 킬링 로맨스", "10. 치치핑핑의 쿵쿵따 탐험대",]


// 구조체라 모두 프로토콜을 채택한 것임
struct MovieData: Codable {
    let boxOfficeResult: BoxOfficeResult
}

// MARK: - BoxOfficeResult
struct BoxOfficeResult: Codable {
    let dailyBoxOfficeList: [DailyBoxOfficeList]
}

// MARK: - DailyBoxOfficeList
struct DailyBoxOfficeList: Codable {
    
    let movieNm: String
    let audiAcc: String // 누적관객수를 출력합니다.
    let audiCnt: String // 해당일의 관객수를 출력합니다.
    let salesShare: String // 해당일자 상영작의 매출총액 대비 해당 영화의 매출비율을 출력합니다.
    let salesAcc: String // 누적매출액을 출력합니다.
    
}



class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
    // 셀에 네트워크 작업이후 디코드한 데이터를 찍기위해 생성
    var movieData : MovieData?
    
    // 날짜 자동 지정하기위해 var로 변환
    var movieURL = "https://kobis.or.kr/kobisopenapi/webservice/rest/boxoffice/searchDailyBoxOfficeList.json?key=4d5d8aaff18ee7542b218db4a2632b6b&targetDt="
    // http에 s붙여주기
    
    @IBOutlet weak var table: UITableView!
    
    
    
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        table.delegate = self
        table.dataSource = self
        movieURL += makeYesterdayString() // getData호출전 URL의 어제 날짜 문자 추가
        getData()
    }
    
    func makeYesterdayString() -> String {
            let y = Calendar.current.date(byAdding: .day, value: -1, to: Date())!
            let dateF = DateFormatter()
            dateF.dateFormat = "yyyyMMdd"
            let day = dateF.string(from: y)
            return day
     }
    
//    func getYesterdayDate() -> String {
//        let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: Date()) // 어제 날짜 계산 -2면 그제 날짜
//        let dateFormatter = DateFormatter()
//        dateFormatter.dateFormat = "yyyyMMdd" // 날짜 형식 지정
//
//        if let yesterdayDate = yesterday {
//            let formattedDate = dateFormatter.string(from: yesterdayDate)
//            return formattedDate
//        } else {
//            return "" // 어제 날짜를 가져올 수 없는 경우 빈 문자열 반환
//        }
//    }
    
    
    func getData(){
        if let url = URL(string: movieURL){
            //1. URL(구조체) 객체 생성
            // 실패 가능 생성자라 옵셔널 타입으로 반환되기 때문에 한번 풀어서 사용
            
            let session = URLSession(configuration: .default) // 2. URLSession 객체 만들기
            //  3. URLSession 인스턴스에게 task주기
            let tesk = session.dataTask(with: url) { data, response, error in
                // 에러가 있는지 체크 nil이면 에러가 없다는 것 아닐때 에러가 있음
                if error != nil {
                    print(error!)
                    return
                }
                
                if let JSONdata = data{
                    //print(JSONdata, response!)
                    
                    // utf8 인코딩 방식으로 바꿔서 출력
                    let dataString = String(data: JSONdata, encoding: .utf8)
                    // print(dataString!)
                    
                    let docoder = JSONDecoder()
                    // throws 키워드 있는 메서드는 예외처리를 해줘야함
                    do {
                        let decodedData = try docoder.decode(MovieData.self, from: JSONdata)
                        
                        // 클로저안에서 클래스에 저장속성 사용시 self키워드 필요
                        self.movieData = decodedData
                        
                        // UI 처리 메인 스레드에서 처리
                        DispatchQueue.main.async {
                            self.table.reloadData()
                        }
                        
                        print(decodedData.boxOfficeResult.dailyBoxOfficeList[0].movieNm)
                        print(decodedData.boxOfficeResult.dailyBoxOfficeList[0].salesAcc)
                    }catch{
                        print(error)
                    }
                    
                }
            }
            tesk.resume() // task시작하기 task.resume()
        }
        
    }
    
    // 뷰 컨트롤러에게 segue가 수행될 예정임을 알림
    // segue 실행되기 직전에 자동으로호출되는 메서드
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        let dest = segue.destination as! DetailViewController
        //segue.destination는 UIViewController 타입임 다운 캐스팅해서 사용하기
        let myIndexPath = table.indexPathForSelectedRow!
        let row = myIndexPath.row
        dest.movieName = (movieData?.boxOfficeResult.dailyBoxOfficeList[row].movieNm)!
        // segue.destination 는 UIViewController 형임
        // 보내면 viewDidLoad에서 이름을 바꾸기 때문에 뷰에 올라올때마다 이름이 바뀔수 있는 것임
   
        
    }
    
    
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return 10
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        
        let cell = tableView.dequeueReusableCell(withIdentifier: "myCell", for: indexPath) as! MyTableViewCell
        
        //cell.movieName.text = name[indexPath.row]
        cell.movieName.text = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].movieNm
        //cell.audiAccumulate.text = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].audiAcc
        if let aCnt = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].audiAcc {
                   let numF = NumberFormatter()
                   numF.numberStyle = .decimal
                   let aCount = Int(aCnt)!
                   let result = numF.string(for: aCount)!+"명"
                   cell.audiAccumulate.text = "누적 관객수:\(result)"
                   //cell.audiCount.text = "어제:\(aCnt)명"
               }
        //cell.audiCount.text = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].audiCnt
        if let aCnt = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].audiCnt {
                   let numF = NumberFormatter()
                   numF.numberStyle = .decimal
                   let aCount = Int(aCnt)!
                   let result = numF.string(for: aCount)!+"명"
                   cell.audiCount.text = "어제 관객수:\(result)"
                   //cell.audiCount.text = "어제:\(aCnt)명"
               }
        //cell.salesAcc.text = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].salesAcc
        if let aCnt = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].salesAcc {
                   let numF = NumberFormatter()
                   numF.numberStyle = .decimal
                   let aCount = Int(aCnt)!
                   let result = numF.string(for: aCount)!+"원"
                   cell.salesAcc.text = "누적 매출액:\(result)"
                   //cell.audiCount.text = "어제:\(aCnt)명"
               }
        
        cell.salesShare.text = movieData?.boxOfficeResult.dailyBoxOfficeList[indexPath.row].salesShare
        
       
        return cell
    }
    
    // 테이블 헤더 주기 텍스트를 할때는 이 메서드를 사용하면 되지만 그래픽 같은것을 이용시 viewForHeaderInSection 메서드 이용
    func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
        return "박스오피스(영화진흥위원회제공:"+makeYesterdayString()+")"
    }
    
    func tableView(_ tableView: UITableView, titleForFooterInSection section: Int) -> String? {
        return "Woogie"
    }
    
    
}

//
//  DetailViewController.swift
//  MovieJJK
//
//  Created by comsoft on 2023/05/25.
//

import UIKit
import WebKit
class DetailViewController: UIViewController {
    
    @IBOutlet weak var nameLabel: UILabel!
    var movieName = ""
    @IBOutlet weak var webView: WKWebView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // nameLabel.text = movieName
        navigationItem.title = movieName
        
        /* 크룸 url
        
        guard let url = URL(string: "https://search.naver.com/search.naver?where=nexearch&sm=top_hty&fbm=0&ie=utf8&query=%EB%B0%95%EC%8A%A4%EC%98%A4%ED%94%BC%EC%8A%A4") else {return}
        
         사파리 url search.naver.com/search.naver?sm=tab_hty.top&where=nexearch&query=박스오피스&oquery=영화순위&tqi=ibJS3sprvhGssFKpOfKssssstAw-448005
         url 사용시 주의점 url에 한글이 있어서 동작하지 않음 변환시켜주는 코드 필요
         */
        
        let urlKorString = "https://www.youtube.com/results?search_query="+movieName
        let urlString = urlKorString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
        guard let url = URL(string:urlString) else { return }
        let request = URLRequest(url: url)
        webView.load(request)

    }
    
    
    /*
     // MARK: - Navigation
     
     // In a storyboard-based application, you will often want to do a little preparation before navigation
     override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
     // Get the new view controller using segue.destination.
     // Pass the selected object to the new view controller.
     }
     */
    
}

//
//  MapViewController.swift
//  MovieJJK
//
//  Created by comsoft on 2023/06/01.
//

import UIKit
import WebKit

class MapViewController: UIViewController {

    @IBOutlet weak var webView: WKWebView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let urlKorString = "https://map.naver.com/v5/search/영화관"
        let urlString = urlKorString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
        guard let url = URL(string:urlString) else { return }
        let request = URLRequest(url: url)
        webView.load(request)
        

        // Do any additional setup after loading the view.
    }
    

    /*
    // MARK: - Navigation

    // In a storyboard-based application, you will often want to do a little preparation before navigation
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        // Get the new view controller using segue.destination.
        // Pass the selected object to the new view controller.
    }
    */

}

//
//  CommunityViewController.swift
//  MovieJJK
//
//  Created by comsoft on 2023/06/01.
//

import UIKit
import WebKit

class CommunityViewController: UIViewController {

    @IBOutlet weak var webView: WKWebView!
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let urlKorString = "https://gall.dcinside.com/board/lists/?id=movie2"
        let urlString = urlKorString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
        guard let url = URL(string:urlString) else { return }
        let request = URLRequest(url: url)
        webView.load(request)
        // Do any additional setup after loading the view.
    }
    

    /*
    // MARK: - Navigation

    // In a storyboard-based application, you will often want to do a little preparation before navigation
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        // Get the new view controller using segue.destination.
        // Pass the selected object to the new view controller.
    }
    */

}

//
//  MyTableViewCell.swift
//  MovieJJK
//
//  Created by comsoft on 2023/05/04.
//

import UIKit

class MyTableViewCell: UITableViewCell {

    
   
    @IBOutlet weak var movieName: UILabel!
    @IBOutlet weak var audiCount: UILabel!
    @IBOutlet weak var audiAccumulate: UILabel!
    @IBOutlet weak var salesShare: UILabel!
    @IBOutlet weak var salesAcc: UILabel!
    override func awakeFromNib() {
        super.awakeFromNib()
        // Initialization code
    }

    override func setSelected(_ selected: Bool, animated: Bool) {
        super.setSelected(selected, animated: animated)

        // Configure the view for the selected state
    }

}

extension Double {
    //계산 메서드 get생략으로 확장
    var squared : Double {
    return self * self
    }
}

let myValue: Double = 3.5
print(myValue.squared) //
print(3.5.squared) //Double형 값에도 .으로 바로 사용 가능

enum Compass {
    case North
    case South
    case East
    case West
}

print(Compass.North) //North
var x : Compass //Compass형 인스턴스 x
x = Compass.West // West가 인스턴스임 
print(x, type(of:x)) // West Compass
x = .East
print(x) //East

enum Compass {
    case North
    case South
    case East
    case West
}
var direction : Compass
direction = .South
switch direction { //switch의 비교값이 열거형 Compass
    case .North: //direction이 .North이면 "북" 출력
        print("북")
    case .South:
        print("남")
    case .East:
        print("동")
    case .West:
        print("서") //모든 열거형 case를 포함하면 default 없어도 됨
}

enum Week: String {
    case Mon,Tue,Wed,Thur,Fri,Sat,Sun
    func printWeek() { //메서드도 가능
        switch self {
        case .Mon, .Tue, .Wed, .Thur, .Fri:
          print("주중")
        case .Sat, .Sun:
            print("주말")
        }
    }
}
Week.Sun.printWeek() //레포트
let x = Week.Mon // West가 인스턴스임 
x.printWeek()

enum Color: Int {
case red
case green = 2
case blue
}
print(Color.red) //red
print(Color.blue)
print(Color.red.rawValue) //0
print(Color.blue.rawValue) // 초기화 된 다음 값으로 자동 할당 
// red
// blue
// 0
// 3

enum Week: String {
    case Monday = "월"
    case Tuesday = "화"
    case Wednesday = "수"
    case Thursday = "목"
    case Friday = "금"
    case Saturday //값이 지정되지 않으면 case 이름이 할당됨
    case Sunday // = "Sunday"
}
print(Week.Monday) //Monday
print(Week.Monday.rawValue) //월
print(Week.Sunday)
print(Week.Sunday.rawValue)
// Monday
// 월
// Sunday
// Sunday

//연관 값(associated value)을 갖는 Enum
enum Date {
    case intDate(Int,Int,Int) //(int,Int,Int)형 연관값을 갖는 intDate
    case stringDate(String) //String형 연관값을 값는 stringDate
}

var todayDate = Date.intDate(2023,4,30)
todayDate = Date.stringDate("2023년 5월 20일") //주석처리하면?
switch todayDate {
    case .intDate(let year, let month, let day):
        print("\(year)년 \(month)월 \(day)일")
    case .stringDate(let date):
        print(date)
}

안드로이드 액티비티 생명주기

개발자 aloe — Tue, 30 May 2023 15:57:52 +0900

onPause() 잠시대기 상태 아직 메모리에 남아있음

onStop() 정지상태 : 메모리에서 비워질때 우선 순위가 됨 아직 메모리에 남아있긴함

Destory() 되면 부를때 다시 onCreate() 부터 시작해야함

액티비티 객체 생성 단계

일시 멈춤 상태

정지 되었다가 다시 실행하는 경우

액티비티 생명주기, 실행되는 과정

안드로이드 메모리 관리

https://velog.io/@woga1999/%EC%95%88%EB%93%9C%EB%A1%9C%EC%9D%B4%EB%93%9C-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EC%9E%AC%EC%83%9D%EC%84%B1

안드로이드 메모리에 관하여

Android 런타임(ART)과 Dalvik 가상 머신은 페이징과 메모리 매핑(mmapping)을 사용하여 메모리를 관리합니다. 즉, 새로운 개체를 할당해서든 메모리 매핑된 페이지를 터치해서든 앱이 수정하는 모든 메

velog.io

가비지 컬렉션 동작 방식

https://mangkyu.tistory.com/118

[Java] Garbage Collection(가비지 컬렉션)의 개념 및 동작 원리 (1/2)

1. Garbage Collection(가비지 컬렉션)이란? [ Garbage Collection(가비지 컬렉션)이란? ] 프로그램을 개발 하다 보면 유효하지 않은 메모리인 가바지(Garbage)가 발생하게 된다. C언어를 이용하면 free()라는 함

mangkyu.tistory.com

UDP 서버 만들기 및 채팅 프로그램 만들기

개발자 aloe — Tue, 30 May 2023 11:46:00 +0900

13.1_UDP 프로그래밍_코드공개3.pdf

0.21MB

13.1_UDP 프로그래밍.pdf

1.28MB

13.1_UDP 프로그래밍_코드공개2.pdf

0.18MB

13.1_UDP 프로그래밍_코드공개1.pdf

0.14MB

TCP와 비교해 UDP는 간단함
클 라이언트에서 쏘면 서버 쪽에서 받아주는 것만 처리하면 됨
UDP는 목적지까지 가는 데 아니면 말고
잘 전달됐는지 확인할 수 없으면 ACK 같은 게 없어서

APP

|<= TCP OR UDP

------------------------------------------

O/S

H/W

IP IP IP

LAN LAN LAN

-------------------------------------------

| | |

MAC MAC MAC

sendto 함수는 누구에게 보낼지 일일히 설정 가능

서로 sendto함수를 통해 통로가 만들어지는 것임

TCP와 다르게 UDP 서버는 하나의 소켓만 사용

나만 알면 됨

UDP 서버, 클라이언트 검증 가능

로컬 어드레스 0 0 0 0 의미는 내컴퓨터의 IP가 여러개일때 일단 모두 모아서 이쪽으로 점유하겠다는 뜻

FOREIGN 0 0 0 0누구던 나한테 접속가능

컨트롤 c 종료

통신 가능한 것을 알 수 있음

UdpClient.c

#include <unistd.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <arpa/inet.h> 
#include <sys/types.h>
#include <sys/socket.h>

int main(int argc, char *argv[])
{
    int nSockFd; // 소켓 파일 디스크립터
    char p_Buffer[BUFSIZ]; // 데이터 버퍼
    int nBufferLen; // 버퍼 길이

    struct sockaddr_in stSAddr; // 서버 주소 구조체
    int nSAddr_size; // 주소 구조체 크기

    if (argc != 3)
    {
        printf("Usage: %s <IP Address> <port>\n", argv[0]); 
        return -1;
    }

    // UDP 소켓 생성
    nSockFd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    // 서버 주소 설정
    bzero(&stSAddr, sizeof(stSAddr));
    stSAddr.sin_family = AF_INET;
    stSAddr.sin_addr.s_addr = inet_addr(argv[1]); // 명령줄 인수로 전달된 IP 주소 사용
    stSAddr.sin_port = htons(atoi(argv[2])); // 명령줄 인수로 전달된 포트 번호 사용
    nSAddr_size = sizeof(stSAddr);

    // 데이터 입력 및 송신
    bzero(p_Buffer, BUFSIZ);
    nBufferLen = read(0, p_Buffer, BUFSIZ); // 표준 입력으로부터 데이터를 읽음
    nBufferLen = sendto(nSockFd, p_Buffer, nBufferLen, 0, (struct sockaddr *)&stSAddr, nSAddr_size); // 소켓을 통해 데이터 전송

    if (nBufferLen > 0)
    {
        printf("TX: %s\n", p_Buffer); // 송신한 데이터 출력
    }

    // 데이터 수신
    bzero(p_Buffer, BUFSIZ);
    nBufferLen = recvfrom(nSockFd, p_Buffer, BUFSIZ, 0, (struct sockaddr *)&stSAddr, &nSAddr_size); // 소켓으로부터 데이터 수신

    if (nBufferLen > 0)
    {
        printf("Server Information: \n");
        printf("Addr: %s\n", inet_ntoa(stSAddr.sin_addr)); // 서버의 IP 주소 출력
        printf("Port: %d\n", ntohs(stSAddr.sin_port)); // 서버의 포트 번호 출력
        printf("RX: %s\n", p_Buffer); // 수신한 데이터 출력
    }

    close(nSockFd); // 소켓 닫기
    return 0;
}

위의 코드는 UDP 프로토콜을 사용하여 클라이언트에서 서버로 데이터를 전송하고, 서버로부터 데이터를 수신하는 클라이언트 프로그램입니다.

프로그램 실행 시 명령줄 인수로 서버의 IP 주소와 포트 번호를 입력해야 합니다.

1. UDP 소켓 생성
   - `nSockFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);`
   - AF_INET은 IPv4 주소 체계를 사용함을 나타내며, SOCK_DGRAM은 데이터그램 소켓을 생성하라는 의미입니다.

2. 서버 주소 설정
   - `bzero(&stSAddr, sizeof(stSAddr));`
   - 서버 주소 구조체(stSAddr)를 초기화합니다.
   - `stSAddr.sin_family = AF_INET;` : 주소 체계를 IPv4로 설정합니다.
   - `stSAddr.sin_addr.s_addr = inet_addr(argv[1]);` : 명령줄 인수로 전달된 IP 주소를 설정합니다.
   - `stSAddr.sin_port = htons(atoi(argv[2]));` : 명령줄 인수로 전달된 포트 번호를 설정합니다.
   - `nSAddr_size = sizeof(stSAddr);` : 주소 구조체의 크기를 저장합니다.

3. 데이터 입력 및 송신
   - `nBufferLen = read(0, p_Buffer, BUFSIZ);` : 표준 입력으로부터 데이터를 읽어옵니다.
   - `nBufferLen = sendto(nSockFd, p_Buffer, nBufferLen, 0, (struct sockaddr *)&stSAddr, nSAddr_size);` : 소켓을 통해 서버로 데이터를 전송합니다.
   - 전송한 데이터를 출력합니다.

4. 데이터 수신
   - `nBufferLen = recvfrom(nSockFd, p_Buffer, BUFSIZ, 0, (struct sockaddr *)&stSAddr, &nSAddr_size);` : 소켓으로부터 서버로부터 데이터를 수신합니다.
   - 수신한 데이터와 서버의 IP 주소, 포트 번호를 출력합니다.

5. 소켓 닫기
   - `close(nSockFd);` : 소켓을 닫습니다.

즉, 이 프로그램은 클라이언트가 서버에 데이터를 전송하고, 서버로부터 응답을 받는 단순한 UDP 통신을 수행하는 것입니다.

nc명령으로 서버를 열고 테스트 해보기

친구와 테스트 해보기

udp는 사진처럼 연결구조가 되어야 통신가능

strncasecmp : 앞에서 부터 4개 같으면

strcasecmp : 이전시간과 조금 다른데 확인 해보기

서버 프로그램 작성

UdpServer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>


int main(int argc, char *argv[])
{
    int nSocketFd; // 소켓 파일 디스크립터
    char pBuffer[BUFSIZ]; // 데이터 버퍼
    int nBufferLen = 0; // 버퍼 길이
    struct sockaddr_in stSAddr; // 서버 소켓 주소 구조체
    struct sockaddr_in stCAddr; // 클라이언트 소켓 주소 구조체
    int nCAddr_size; // 클라이언트 소켓 주소 구조체 크기

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        return -1;
    }

    // UDP 소켓 생성
    nSocketFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    // 서버 소켓 주소 설정
    memset(&stSAddr, 0, sizeof(stSAddr));
    stSAddr.sin_family = PF_INET;
    stSAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stSAddr.sin_port = htons(atoi(argv[1]));

    // 소켓에 주소 바인딩
    if (bind(nSocketFd, (struct sockaddr *)&stSAddr, sizeof(stSAddr)) < 0)
    {
        printf("Binding Failed.\n");
        return -1;
    }

    do
    {
        // 클라이언트 소켓 주소 구조체 초기화
        nCAddr_size = sizeof(stCAddr);
        memset(pBuffer, 0, BUFSIZ);

        // 클라이언트로부터 데이터 수신
        nBufferLen = recvfrom(nSocketFd, pBuffer, BUFSIZ, 0, (struct sockaddr *)&stCAddr, &nCAddr_size);

        if (nBufferLen > 0)
        {
            printf("Client Information: \n");
            printf("Addr: %s\n", inet_ntoa(stCAddr.sin_addr)); // 클라이언트의 IP 주소 출력
            printf("Port: %d\n", ntohs(stCAddr.sin_port)); // 클라이언트의 포트 번호 출력
            printf("RX: %s\n", pBuffer); // 수신한 데이터 출력

            if (strncasecmp(pBuffer, "exit", 4) == 0)
                break;
        }
        else if (nBufferLen <= 0)
            break;

        // 클라이언트로 데이터 전송
        nBufferLen = sendto(nSocketFd, pBuffer, nBufferLen, 0, (struct sockaddr *)&stCAddr, nCAddr_size);
    } while (1);

    close(nSocketFd); // 소켓 닫기
    return 0;
}

위의 코드는 UDP 프로토콜을 사용하여 클라이언트로부터 데이터를 수신하고, 수신한 데이터를 다시 클라이언트로 전송하는 간단한 서버 프로그램입니다.

클라쪽에서 잘 오는 것을 확인 할 수 이음

클라이언트 쪽에서 exit가 꼭 필요함 컨트롤 + c 해서 종료하면 포트를 물고있어서 자원을 놔주지 못하는 경우가 생길 수 있음 다음번에 실행했을때 정상적인 코드 실행이 안될 수 있음

UdpClient2.c

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/poll.h>


int main(int argc, char *argv[])
{
    int nSockFd; // 소켓 파일 디스크립터
    struct pollfd rfds[2]; // 파일 디스크립터 감시를 위한 pollfd 구조체 배열
    int nRetval; // poll() 함수의 반환값

    char p_Buffer[BUFSIZ]; // 데이터 버퍼
    int nBufferLen; // 버퍼 길이

    struct sockaddr_in stSAddr; // 서버 주소 구조체
    int nSAddr_size; // 주소 구조체 크기

    if (argc != 3)
    {
        printf("Usage: %s <IP Address> <port>\n", argv[0]);
        return -1;
    }

    // UDP 소켓 생성
    nSockFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    // 키보드 입력을 감시하는 파일 디스크립터 설정
    rfds[0].fd = 0; // 표준 입력(키보드)의 파일 디스크립터
    rfds[0].events = POLLIN; // 입력 가능한 데이터의 상태 변화를 감시

    // 소켓 입력을 감시하는 파일 디스크립터 설정
    rfds[1].fd = nSockFd; // 소켓의 파일 디스크립터
    rfds[1].events = POLLIN; // 입력 가능한 데이터의 상태 변화를 감시

    // 서버 주소 설정
    bzero(&stSAddr, sizeof(stSAddr));
    stSAddr.sin_family = AF_INET;
    stSAddr.sin_addr.s_addr = inet_addr(argv[1]); // 명령줄 인수로 전달된 IP 주소 사용
    stSAddr.sin_port = htons(atoi(argv[2])); // 명령줄 인수로 전달된 포트 번호 사용
    nSAddr_size = sizeof(stSAddr);

    do
    {
        nRetval = poll(rfds, 2, 1000); // 파일 디스크립터 감시
        if (nRetval < 0)
            break;
        if (nRetval == 0)
            continue;

        // 키보드 입력 처리
        if (rfds[0].revents & POLLIN)
        {
            bzero(p_Buffer, BUFSIZ);
            nBufferLen = read(0, p_Buffer, BUFSIZ); // 키보드로부터 데이터를 읽음
            nBufferLen = sendto(nSockFd, p_Buffer, nBufferLen, 0, (struct sockaddr *)&stSAddr, nSAddr_size); // 소켓을 통해 데이터 전송

            if (nBufferLen > 0)
            {
                printf("TX: %s", p_Buffer); // 송신한 데이터 출력
                if (strncasecmp(p_Buffer, "exit", 4) == 0)
                    break;
            }
       

              // 소켓 수신 처리
        if (rfds[1].revents & POLLIN)
        {
            bzero(p_Buffer, BUFSIZ);
            nBufferLen = recvfrom(nSockFd, p_Buffer, BUFSIZ, 0, (struct sockaddr *)&stSAddr, &nSAddr_size); // 소켓으로부터 데이터 수신
            if (nBufferLen > 0)
            {
                printf("RX: %s", p_Buffer); // 수신한 데이터 출력
                if (strncasecmp(p_Buffer, "exit", 4) == 0)
                    break;
            }
        }

    } while (1);

    close(nSockFd); // 소켓 닫기
    return 0;
}

위의 코드는 UDP 프로토콜을 사용하여 클라이언트로부터 키보드 입력을 받아 서버로 전송하고, 동시에 서버로부터 데이터를 수신하여 출력하는 간단한 클라이언트 프로그램입니다.

프로그램 실행 시 명령줄 인수로 서버의 IP 주소와 포트 번호를 전달해야 합니다. 프로그램은 키보드 입력과 소켓 입력을 모두 감시하고, 데이터를 송수신하며 "exit"라는 입력이 들어오면 종료됩니다.

클라이언트와 서버가 채팅앱처럼 동작 하는 것을 확인 할 수 있음

UdpServer2.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/poll.h>


int main(int argc, char *argv[])
{
    int nSocketFd;                   // 소켓 파일 디스크립터
    char pBuffer[BUFSIZ];             // 버퍼
    int nBufferLen = 0;               // 버퍼 길이
    struct sockaddr_in stSAddr;       // 서버 소켓 주소 구조체
    struct sockaddr_in stCAddr;       // 클라이언트 소켓 주소 구조체
    int nCAddr_size;                  // 클라이언트 소켓 주소 구조체의 길이
    
    int nRetval;
    struct pollfd rfds[2];            // 표준 입력(키보드 입력), 소켓 입력을 감시하는 pollfd 구조체 배열


    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        return -1;
    }
    
    // UDP 소켓 생성
    nSocketFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    
    // 키보드 입력 설정
    rfds[0].fd = 0;                   // 표준 입력(키보드 입력)의 파일 디스크립터 0
    rfds[0].events = POLLIN;          // 입력 가능 이벤트를 감시
    rfds[0].revents = 0;              // 이벤트 상태 초기화
    
    // 소켓 입력 설정
    rfds[1].fd = nSocketFd;           // 소켓 파일 디스크립터
    rfds[1].events = POLLIN;          // 입력 가능 이벤트를 감시
    rfds[1].revents = 0;              // 이벤트 상태 초기화
    
    // 서버 소켓 주소 초기화
    memset(&stSAddr, 0, sizeof(stSAddr));
    stSAddr.sin_family = PF_INET;                          // IPv4 주소 패밀리
    stSAddr.sin_addr.s_addr = htonl(INADDR_ANY);           // 모든 IP 주소로부터의 입력을 허용
    stSAddr.sin_port = htons(atoi(argv[1]));               // 명령줄 인수로 전달된 포트 번호 설정

    // 소켓과 주소를 바인딩
    if (bind(nSocketFd, (struct sockaddr *)&stSAddr, sizeof(stSAddr)) < 0)
    {
        printf("Binding Failed.\n"); 
        return -1;
    }
    
    do
    {
        // poll을 이용하여 입력을 감시
        nRetval = poll(rfds, 2, 1000);       // 1000ms(1초) 동안 입력을 감시
        if (nRetval < 0)
            break;
        if (nRetval == 0)
            continue;
        
        // 키보드 입력 처리
        if (rfds[0].revents & POLLIN)          // 표준 입력(키보드 입력)에서 입력 가능 이벤트가 발생한 경우
        {
            memset(pBuffer, 0, BUFSIZ);       // 버퍼 초기화
            nBufferLen = read(0, pBuffer, BUFSIZ);    // 표준 입력(키보드 입력)에서 데이터를 읽어옴
            nBufferLen = sendto(nSocketFd, pBuffer, nBufferLen, 0,
                    (struct sockaddr *)&stCAddr, nCAddr_size);    // 소켓을 통해 읽어온 데이터를 전송

            if (nBufferLen > 0)
            {
                printf("TX: %s", pBuffer);      // 전송한 데이터 출력
                if (strncasecmp(pBuffer, "exit", 4) == 0)     // 전송한 데이터가 "exit"일 경우 종료
                    break;
            }
        }
        
        // 소켓 수신 처리
        if (rfds[1].revents & POLLIN)          // 소켓에서 입력 가능 이벤트가 발생한 경우
        {
            memset(pBuffer, 0, BUFSIZ);       // 버퍼 초기화
            nBufferLen = recvfrom(nSocketFd, pBuffer, BUFSIZ, 0, 
            (struct sockaddr *)&stCAddr, &nCAddr_size);    // 소켓을 통해 데이터를 수신

            if (nBufferLen > 0)
            {
                printf("RX: %s", pBuffer);      // 수신한 데이터 출력
                if (strncasecmp(pBuffer, "exit", 4) == 0)     // 수신한 데이터가 "exit"일 경우 종료
                    break;
            }
        }
    } while(1);
    
    close(nSocketFd);         // 소켓 종료
    return 0;
}

위 코드는 UDP 소켓을 사용하여 클라이언트와 서버 간에 텍스트 데이터를 주고받는 프로그램입니다. 프로그램은 다음과 같은 동작을 수행합니다:

1. 소켓 생성 및 초기화:
   - `socket()` 함수를 사용하여 UDP 소켓을 생성합니다.

2. 주소 설정 및 바인딩:
   - `stSAddr` 구조체를 초기화하고, 서버의 IP 주소와 포트 번호를 설정합니다.
   - `bind()` 함수를 사용하여 소켓을 해당 주소에 바인딩합니다.

3. `poll()` 함수를 사용한 입력 감시:
   - `poll()` 함수를 사용하여 표준 입력(키보드 입력) 및 소켓 입력을 감시합니다.
   - `poll()` 함수의 타임아웃 값으로 1000ms(1초)을 설정합니다.

4. 키보드 입력 처리:
   - 표준 입력(키보드 입력)에서 입력 가능 이벤트가 발생한 경우, 데이터를 읽어옵니다.
   - 읽어온 데이터를 소켓을 통해 클라이언트에게 전송합니다.
   - 전송한 데이터를 출력하고, 만약 데이터가 "exit"일 경우 프로그램을 종료합니다.

5. 소켓 수신 처리:
   - 소켓에서 입력 가능 이벤트가 발생한 경우, 데이터를 수신합니다.
   - 수신한 데이터를 출력하고, 만약 데이터가 "exit"일 경우 프로그램을 종료합니다.

6. 반복 실행:
   - 프로그램은 계속해서 입력 이벤트를 감시하고 데이터를 주고받습니다.
   - 프로그램 종료 조건이 충족될 때까지 루프를 반복합니다.

7. 소켓 종료:
   - `close()` 함수를 사용하여 소켓을 닫고 자원을 해제합니다.

따라서, 이 코드는 UDP 소켓을 사용하여 클라이언트와 서버 간에 상호작용하는 간단한 채팅 프로그램입니다. 키보드로부터 입력을 받아 서버로 전송하고, 서버로부터 수신한 데이터를 출력합니다. 데이터가 "exit"일 경우 프로그램이 종료됩니다.