내일도이렇게

iOS 애플 로그인 연동

내일도이렇게 — Sun, 21 Jan 2024 14:52:09 +0900

1. Project > Signining & Capablilities

2. Apple Developer - Certificates, Identifiers & Profiles

애플 로그인 추가할 앱에 Sign In with Apple 추가

3. 애플 로그인 버튼 추가

4. 코드 구현

ASAuthorizationControllerPresentationContextProviding

- 인증 컨트롤러를 어느 컨트롤러나 뷰에 표시할지 결정하는데 사용

import AuthenticationServices

extension Root.ViewController: ASAuthorizationControllerPresentationContextProviding {
    func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
        return self.view.window!
    }
}

// 애플 로그인 버튼 실행 
appleLoginButton.rx.tap
         .bind {
            self.startSignInWithAppleFlow()
         }.disposed(by: disposeBag)

// 애플 로그인 요청 
func startSignInWithAppleFlow() {
        let nonce = randomNonceString()
        currentNonce = nonce
        let appleIDProvider = ASAuthorizationAppleIDProvider()
        let request = appleIDProvider.createRequest()
        request.requestedScopes = [.fullName, .email]
        request.nonce = sha256(nonce)
        
        let authorizationController = ASAuthorizationController(authorizationRequests: [request])
        authorizationController.delegate = self
        authorizationController.presentationContextProvider = self
        authorizationController.performRequests()
 }
    
 private func sha256(_ input: String) -> String {
        let inputData = Data(input.utf8)
        let hashedData = SHA256.hash(data: inputData)
        let hashString = hashedData.compactMap {
            return String(format: "%02x", $0)
        }.joined()
        
        return hashString
 }
    
  // Adapted from https://auth0.com/docs/api-auth/tutorials/nonce#generate-a-cryptographically-random-nonce
 private func randomNonceString(length: Int = 32) -> String {
        precondition(length > 0)
        let charset: Array<Character> =
            Array("0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._")
        var result = ""
        var remainingLength = length
        
        while remainingLength > 0 {
            let randoms: [UInt8] = (0 ..< 16).map { _ in
                var random: UInt8 = 0
                let errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random)
                if errorCode != errSecSuccess {
                    fatalError("Unable to generate nonce. SecRandomCopyBytes failed with OSStatus \(errorCode)")
                }
                return random
            }
            
            randoms.forEach { random in
                if remainingLength == 0 {
                    return
                }
                
                if random < charset.count {
                    result.append(charset[Int(random)])
                    remainingLength -= 1
                }
            }
        }
        
        return result
 }

ASAuthorizationControllerDelegate

- 사용자 인증에 대한 처리

 func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
  if let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
            guard let nonce = currentNonce else {
                fatalError("Invalid state: A login callback was received, but no login request was sent.")
            }
            guard let appleIDToken = appleIDCredential.identityToken else {
                print("Unable to fetch identity token")
                return
            }
            guard let idTokenString = String(data: appleIDToken, encoding: .utf8) else {
                print("Unable to serialize token string from data: \(appleIDToken.debugDescription)")
                return
            }
            
            let credential = OAuthProvider.credential(withProviderID: "apple.com", idToken: idTokenString, rawNonce: nonce)
            let credentialResult = try await Auth.auth().signIn(with: oauth)
            
            // ...
            
     }
 }

iOS 구글 로그인 연동

내일도이렇게 — Sun, 21 Jan 2024 13:40:36 +0900

iOS 14 이상 / GoogleSignIn 7.0.0 버전에 대한 구글 로그인 연동

1. GoogleSignIn 설치

pod 'GoogleSignIn', '7.0.0'

2. 파이어베이스 구글 로그인 설정

3. OAuth 클라이언트 ID 만들기

https://developers.google.com/identity/sign-in/ios/start-integrating?hl=ko#get_an_oauth_client_id

iOS 및 macOS용 Google 로그인 시작하기 | Authentication | Google for Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. Switch to English 의견 보내기 iOS 및 macOS용 Google 로그인 시작하기 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류

developers.google.com

설정한 프로젝트의 OAuth client 클릭하여 클라이언트 ID 와 iOS URL 스키마 두가지 정보를 저장해둔다.

Info.plist 에 행 추가하여 GIDClientId: 클라이언트 ID 를 추가한다.

프로젝트 > Info >URL Types

+ 버튼으로 추가하여 URL Schemes 에 URL Schemes 에 iOS URL 스키마를 입력한다.

4. 코드 구현하기

// AppDelegate.Swift    

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        return GIDSignIn.sharedInstance.handle(url)
}

// 로그인 호출 
let googleResult = try await GIDSignIn.sharedInstance
                     .signIn(withPresenting: self ?? Root.ViewController(viewModel: Root.ViewModel()))


let authentication = googleResult.user
let authIdToken = authentication.idToken
            
let credential = GoogleAuthProvider.credential(withIDToken: authIdToken?.tokenString ?? "", accessToken: authentication.accessToken.tokenString)
let credentialResult = try await Auth.auth().signIn(with: credential)

만보기 iOS 앱 개발기

내일도이렇게 — Mon, 9 Oct 2023 16:46:13 +0900

2022년 06월에 블록체인 서비스를 하고 있는 회사에 입사하여 혼자서 프로젝트 세팅부터 출시까지

만보기 iOS 앱 개발 대해 간략하게 정리하고자 한다.

프로젝트

지원 버전, 언어
아키텍처
UI 개발
라이브러리 관리
연동 작업 (푸시, 로깅 등)
배포(CI/CD)

프로젝트

지원 버전, 언어

최소 지원 버전 iOS 13, Swift 5.7.2로 개발하여 Async/Await를 사용하여 API 비동기 처리하였습니다.

 // View 에서 /me API 호출 

 Task {
        do {
           let userInfo = try await self.viewModel.getMe(authorization: authorization, deviceId: deviceId)
        } catch {
          // 에러 처리 
      }
  }

  // ViewModel  
  func getMe(authorization: String, deviceId: String) async throws -> UserInfo {
        do {
            let result = try await self.userNetwork.getMe(authorization: authorization, deviceId: deviceId)
            return result
        } catch {
            throw error
        }
    }

// /me API 호출하는 메소드 
func getMe(authorization: String, deviceId: String) async throws -> UserInfo {
        
        let url = UserEndPoint.me.url
        var request = URLRequest(url: url)
        request.httpMethod = RequestMethod.get.rawValue
        request.addValue(authorization, forHTTPHeaderField: "Authorization")
        request.addValue(deviceId, forHTTPHeaderField: "x-device-id")
        
        do {
            let (data, response) = try await URLSession.shared.data(from: request)
            guard let response = response as? HTTPURLResponse else { throw ErrorModel.noResponse }
                        
            switch response.statusCode {
            case 200 ... 299 :
                let decoder = JSONDecoder()
          
                guard let result = try? decoder.decode(UserInfo.self, from: data)
                else {
                    throw ErrorModel.invalidJSON
                }
                return result
        // 상태 코드 처리 
  }

아키텍처

MVVM 아키텍처 사용

UI 개발 방법

StoryBoard 를 사용하지 않고 코드기반인 Snapkit으로 사용하였음

라이브러리 관리

CocoaPods 으로 라이브러리 관리하였습니다.

사용한 라이브러리

RxSwift: 비동기 처리
SwiftGen: 에셋 카탈로그 코드 처리
SnapKit: UI 코드 처리
Firebase: 파이어베이스 관련
Kingfisher: 이미지 다운로드 / 캐싱
PanModal: 바텀 시트 UI
lottie-ios: 로티 애니메이션 처리
swiftLint: 코딩 컨벤션을 관리

연동작업

푸시

- OneSignal: 앱 푸시 처리에 대해 사용

이벤트 로깅

- Firebase Analytics: 사용자 로그 이벤트를 Firebase에 로그 수집

크래시분석

- Firebase Crashlytics: 앱 비정상 종료 데이터를 감지하여 어떤 부분이 비정상 되는지 파악할 수 있었습니다.

광고 연동

- Adop: 배너/비디오/전면 광고 플랫폼을 이용하여 광고 작업을 하였습니다.

배포

초기에 Github Actions 을 사용하여 빌드 테스트 및 배포를 하였지만 스크립트 오류로 인해 지금은 사용 못하고 있어
추후에 개선할 점입니다.

현재 수동으로 Xcode Archive로 데브/라이브앱 구분하여 아카이브 하여 TestFlight에 업로드를 진행하고 있습니다.

개선점

테스트 코드 작성

CI/CD 개선

SwiftUI

아키텍처 연구

iOS 환경별 Build 세팅

내일도이렇게 — Sun, 9 Apr 2023 21:31:19 +0900

앱을 운영하다 보면 개발/라이브 버전 등 다양한 환경에 따라 Target을 만들 필요가 있는데 이에 대해 알아보고자 한다.

1. Product bundle Identifier 구분

앱의 고유 식별자인 Product bundle Identifier 를 디버그/릴리즈 버전을 다르게 지정한다.

프로젝트 탐색기에서 앱 target > Build Settings > Product Bundle Identifier

2. 앱 아이콘 구분

디버그/릴리즈 버전 앱 식별하기 위해 앱 아이콘 이미지를 다르게 지정한다.

프로젝트 탐색기 앱의 target > Build Settings > Primary App Icon Set Name 디버그/릴리즈 버전에 맞게 앱 아이콘을 지정한다.

3. Manage Schemes를 통해 Debug 용 Scheme 추가

Debug Schemes를 추가하므로 Signing 이 Debug/ Release 가 추가된 걸 확인할 수 있다.

디버그/릴리즈으로 앱이 구분이 된다.

Application 상태값

내일도이렇게 — Sun, 9 Apr 2023 20:36:53 +0900

iOS 앱의 상태값은 UIApplication 의 appilcationState 를 통해 확인할 수 있다.

UIApplication.State.active

앱이 활성화된 상태
앱이 실행중이며, 현재 사용자 인터페이스가 화면에 표시되고 있음

UIApplication.State.inactive

앱이 비활성화 상태
앱이 실행 중이지만, 현재 사용자 인터페이스가 화면에 표시되지 않는 상태

UIApplication.State.background

앱이 백그라운드에 있는 상태
앱이 백그라운드에서 실행 중이며, 사용자 인터페이스가 화면에 표시되지 않는다.

푸시 메세지 터치시 앱 상태에 따라서 다르게 처리 할 수 있다.

 func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], 
   fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
 
         if application.applicationState == .active  {
         
         } else if  application.applicationState == .background {
         
         } else if application.applicationState == .inactive {
         
         }
 }

iOS ViewController 생명주기

내일도이렇게 — Sun, 3 Jul 2022 15:52:55 +0900

View controller Life Cycle - https://www.edwith.org/boostcourse-ios/lecture/16858/

loadView

뷰 컨트롤러의 기본 view 생성하고 할당

viewDidLoad

메모리에 처음 로드될 때 한번 호출

viewWillLayoutSubviews

뷰의 바운드가 최종적으로 결정되는 최초 시점

viewDidLayoutSubviews

서브 뷰의 레이아웃이 결정되고 난 후에 호출

viewWillAppear

화면이 나타나기 직전에 호출
화면이 나타날때마다 수행하는 작업

viewDidAppear

화면이 나타나면 호출

viewWillDisapper

화면이 사라지기 직전에 호출

viewDidDisappear

사라진 후에 호출

※ 메서드들 사용할 때는 override 와 super 키워드를 작성해야한다.

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

[RxSwift] Subject 알아보기

내일도이렇게 — Tue, 19 Apr 2022 23:26:26 +0900

PublishSubject

빈 상태로 시작하여 새로운 값만을 subscriber 에 방출한다.

구독 이후에 발생하는 모든 이벤트를 전달받는다.

let disposeBag = DisposeBag()

print("-------publishSubject-------")
let publishSubject = PublishSubject<String>()

publishSubject.onNext("여러분 안녕하세요?")

let 구독자1 = publishSubject
    .subscribe(onNext: {
        print($0)
    })
//    .disposed(by: disposeBag)

publishSubject.on(.next("1"))
publishSubject.onNext("2")

let 구독자2 = publishSubject
    .subscribe {
        print("두번째 구독:", $0.element ?? $0)
    }

publishSubject.onNext("3")

구독자1.dispose()

publishSubject.onNext("4")
publishSubject.onCompleted()

publishSubject.onNext("5")

구독자2.dispose()


publishSubject
    .subscribe {
        print("세번째 구독:", $0.element ?? $0)
    }
    .disposed(by: disposeBag)

publishSubject.onNext("찍힐까요?")

-------publishSubject-------
1
2
3
두번째 구독: 3
두번째 구독: 4
두번째 구독: completed
세번째 구독: completed

BehaviorSubject

하나의 초기값을 가진 상태로 시작하여, 새로운 subscriber 에게 초기값 또는 최신값을 방출한다.

구독 전에 발생한 최근 요소와 이후에 발생하는 모든것들을 전달 받는다.

print("-------behaviorSubject-------")
enum SubjectError: Error {
    case error1
}

let behaviorSubject = BehaviorSubject<String>(value: "초기값")

behaviorSubject.onNext("첫번째값")

behaviorSubject.subscribe {
    print("첫번째 구독:", $0.element ?? $0)
}
.disposed(by: disposeBag)

behaviorSubject.onError(SubjectError.error1)

behaviorSubject.subscribe {
    print("두번째 구독:", $0.element ?? $0)
}
.disposed(by: disposeBag)

let value = try? behaviorSubject.value()
print(value)

-------behaviorSubject-------
첫번째 구독: 첫번째값
첫번째 구독: error(error1)
두번째 구독: error(error1)
nil

ReplaySubject

버퍼를 두고 초기화하며, 버퍼 사이즈 만큼의 값들을 유지하면서 새로운 subscriber 에게 방출한다.

모든 구독 이전에 발생한 내용을 받고 싶다면 RelaySubject 를 사용한다.

print("-------ReplaySubject-------")
let replaySubject = ReplaySubject<String>.create(bufferSize: 2)

replaySubject.onNext("a")
replaySubject.onNext("b")
replaySubject.onNext("c")

replaySubject.subscribe {
    print("첫번째 구독:", $0.element ?? $0)
}
.disposed(by: disposeBag)

replaySubject.subscribe {
    print("두번째 구독:", $0.element ?? $0)
}
.disposed(by: disposeBag)

replaySubject.onNext("d")
replaySubject.onError(SubjectError.error1)
replaySubject.dispose()

replaySubject.subscribe {
    print("세번째 구독:", $0.element ?? $0)
}
.disposed(by: disposeBag)

-------ReplaySubject-------
첫번째 구독: b
첫번째 구독: c
두번째 구독: b
두번째 구독: c
첫번째 구독: d
두번째 구독: d
첫번째 구독: error(error1)
두번째 구독: error(error1)
세번째 구독: error(Object `RxSwift.(unknown context at $12d722e70).ReplayMany<Swift.String>` was already disposed.)

Reference

https://fastcampus.co.kr/dev_online_iosapp

https://reactivex.io/documentation/subject.html

https://pilgwon.github.io/blog/2018/10/08/Learn-Master-the-Basics-of-RxSwift-in-10-Minutes.html

RxSwift 개념

내일도이렇게 — Wed, 13 Apr 2022 17:46:55 +0900

RxSwift

Swift 에서 ReactiveX를 적용시켜 비동기 프로그래밍을 직관적으로 작성할 수 있도록 도와주는 라이브러리

RxSwift 사용하는 이유

downloadJson 함수를 처리한 다음에 동기적으로 해야하는 작업들이 많아진다면 콜백 지옥이 발생하게 된다.

// escaping closure를 사용해서 결과값 전달.
func downloadJson(_ url: String, _ completion: @escaping ((String?) -> Void))? {
    DispatcheQueue.global().async {
        let url = URL(string: url)!
        let data = try! Data(contentsOf: url)
        let json = String(data: data, encoding: .utf8)
        DispatchQueue.main.async {
            completion?(json)
        }
    }
}

@IBOutlet var activityIndicator: UIActivityIndicatorView!

@IBAction func onLoad() {
    editView.text = ""
    setVisibleWithAnimation(self.activityIndicator, true)

    downloadJson(MEMBER_LIST_URL) { json in
        self.editView.text = json
        self.setVisibleWithAnimation(self.activityIndicator, false)
        
        self.downloadJson(MEMBER_LIST_URL) { json in
            self.editView.text = json
            self.setVisibleWithAnimation(self.activityIndicator, false)
          
          
          self.downloadJson(MEMBER_LIST_URL) { json in
            self.editView.text = json
            self.setVisibleWithAnimation(self.activityIndicator, false)
            
            /...
            
    	   }   
    	}
    }
}

콜백 함수를 없애기 위해 closure 대신 return 값을 받아서 처리할수 있게 변형한다면 아래와 같다.

class 나중에생기는데이터<T> {
    private let task: (@escaping (T) -> Void) -> Void
    
    init(task: @escaping (@escaping (T) -> Void) -> Void) {
        self.task = task
    }
    
    func 나중에오면(_ f: @escaping (T) -> Void) {
        task(f)
    }
}

func downloadJson(_ url : String) -> 나중에생기는데이터<String?> {
    return 나중에생기는데이터() { f in
        let url = URL(string: url)!
        let data = try! Data(contentsof: url)
        let json = String(data: data, encoding: .utf8)
        DispatchQueue.main.async {
            f(json)
        }
    }
}

@IBOutlet var activityIndicator: UIActivityIndicatorView!

@IBAction func onLoad() {
    editView.text = ""
    setVisibleWithAnimation(self.activityIndicator, true)
    
    
    let json: 나중에생기는데이터<String?> = downloadJson(MEMBER_LIST_URL)
    
    // task 를 실행하는데, task의 인자인 f라는 함수를 넘겨주고 있다.
    // f에 들어가는 인자는 json으로 받아서 사용.
    json.나중에오면 { json in
        self.editView.text = json
        self.setVisibleWithAnimation(self.activityIndicator, false)
    }

이 아이디어로 나온게 RxSwift 인데 아래 두가지를 처리해주면 된다.

비동기로 생기는 데이터를 Observable로 감써서 리턴하는 방법
Observable 로 오는 데이터르 받아서 처리하는 방법

Observable 을 이용해서 만들면 클로저 없이 리턴형식으로 비동기를 처리할 수 있다.

1. 비동기로 생기는 데이터를 Observable로 감써서 리턴하는 방법

Observable의 생명주기

1. create

2. subscribe - subscribe 가 있을 때 동작

3. onNext

4. onCompleted / onError ( 끝 )

5. Disposed - dispose 를 동작하면 재사용 불가능

func downloadJson(_ url: String) -> Observable<String?> {

    // 비동기로 생기는 데이터를 observable로 감싸서 return
    return Observable.create() { emitter in
        let url = URL(string: MEMBER_LIST_URL)!
        
        let task = URLSession.shaerd.dataTask(with: url) { (data, _, err) in
        
            guard err == nil else {
                emitter.onError(err!)
                return
            }
            
            if let data = data, let json = String(data: data, encoding: .utf8) {
                emitter.onNext(json)
            }
            
            emitter.onCompleted()
        }
        
        task.resume()
        
        // dispose가 불렸을 때 task를 cancel
        return Disposables.create() {
            task.cancel()
        }
    }
}

2. Observable 로 오는 데이터를 받아서 처리하는 방법

@IBAction func onLoad() {
    editView.text = ""
    setVisibleWithAnimation(self.activityIndicator, true)
    

    let observable = downloadJson(MEMBER_LIST_URL)
    
    let disposable = observable.subscribe { event in
        switch event {
        case .next(let json):
           
            DispatchQueue.main.async {
                self.editView.text = json 
                self.setVisibleWithAnimation(self.activityIndicator, false)
            }
        case .error(let error):
            break
        case .completed:
            break
        }
    }
    
    disposable.dispose()
}

Reference

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

[RxSwift] Single,Maybe,Completable 알아보기

내일도이렇게 — Tue, 12 Apr 2022 12:38:38 +0900

Single

success 또는 error 이벤트를 한 번만 방출될 수 있다.

var disposeBag = DisposeBag()

enum TraitsError: Error {
    case single
    case maybe
    case completable
}

print("-------Single1-------") // 성공시 
Single<Result<String, TraitsError>>.just(.success("✅"))
    .subscribe(onSuccess: {
        print($0)
    }, onFailure: { _ in
        print("error")
    }, onDisposed: {
        print("disposed")
    })
    .disposed(by: disposeBag)

print("-------Single2-------") // 실패시
Observable<Result<String, TraitsError>>.just(.failure(.single))
    .asSingle()
    .subscribe(onSuccess: {
        print("success: \($0)")
    }, onFailure: {
        print("error: \($0.localizedDescription)")
    }, onDisposed: {
        print("disposed")
    })
    .disposed(by: disposeBag)

Single 를 이용한 decode 예제

print("------single------")
struct SomeJSON: Decodable {
    let name: String
}

enum JSONError: Error {
    case decodingError
}

let json1 = """
    {"name":"hello"}
"""


func decode(json: String) -> Single<SomeJSON> {
    Single<SomeJSON>.create { observer in
        let disposable = Disposables.create()
        
        guard let data = json.data(using: .utf8),
              let json = try? JSONDecoder().decode(SomeJSON.self, from: data) else {
            
            observer(.failure(JSONError.decodingError))
            return disposable
        }
        
        observer(.success(json))
        return disposable
    }
}

decode(json: json1)
    .subscribe{
        switch $0 {
        case .success(let json):
            print(json.name)
        case .failure(let error):
            print(error)
        }
    }
    .disposed(by: disposeBag)
    
------single------
hello

Completable

comleted 이벤트 또는 error 이벤트를 방출될 수 있다.

print("-------Completable-------")
Completable.create { completable in
    completable(.completed)
    return Disposables.create()
}
.subscribe(onCompleted: {
    print("completed")
}, onError: {
    print("error: \($0.localizedDescription)")
}, onDisposed: {
    print("disposed")
})
.disposed(by: disposeBag)


-------Completable-------
completed
disposed

Maybe

success, completed , error 모두 방출될 수 있다.

print("-------Maybe1-------")
Maybe<Result<String, TraitsError>>.just(.success("✅"))
    .subscribe(onSuccess: {
        print("success: \($0)")
    }, onError: {
        print("error: \($0.localizedDescription)")
    }, onCompleted: {
        print("completed")
    }, onDisposed: {
        print("disposed")
    })
    .disposed(by: disposeBag)
 
 -------Maybe1-------
success: success("✅")
disposed

Reference

https://fastcampus.co.kr/dev_online_iosapp

[RxSwift] Observable 알아보기

내일도이렇게 — Tue, 12 Apr 2022 11:58:14 +0900

Observable<T>

T 형태의 데이터 snapshot 을 전달 할 수 있는 일련의 이벤트를 비동기적으로 생성하는 기능
하나 이상의 observers 가 실시간으로 어떤 이벤트에 반응
세 가지 유형의 이벤트만 방출

enum Event<Element> { 
    case next(Element)  // next element 
    case error(Swift.Error)  // sequence failed with error 
    case completed  // sequence terminated successfully
}

Observable 생명주기

Observable 은 어떤 구성요소를 가지는 next 이벤트를 계속해서 방출할 수 있다.
error 이벤트를 방출하여 완전 종료될 수 있다.
complete 이벤트를 방출하여 완전 종료 될 수 있다.

just, of, from

print("-------just-------")
Observable.just(1)   // 하나의 요소만 가능
    .subscribe(onNext: {
        print($0)
    })
-------just-------
1


print("-------of1-------")
Observable.of(1, 2, 3)
    .subscribe(onNext: {
        print($0)
    })
-------of1-------
1
2
3

print("-------of2-------")
Observable.of([1, 2, 3])
    .subscribe(onNext: {
        print($0)
    })
-------of2-------
[1, 2, 3]


print("-------from-------") // 배열만 받는다.
Observable.from([1, 2, 3])
    .subscribe(onNext: {
        print($0)
    })
    .dispose()
-------from-------
1
2
3

range

print("------range------") // 범위
Observable.range(start: 1, count: 9)
    .subscribe(onNext: {
        print("2*\($0)=\(2*$0)")
    })
    
    
------range------
2*1=2
2*2=4
2*3=6
2*4=8
2*5=10
2*6=12
2*7=14
2*8=16
2*9=18

create

print("------create1------")
Observable.create { observer -> Disposable in
    observer.onNext(1)
    observer.onCompleted()
    observer.onNext(2)
    return Disposables.create()
}
.subscribe(onNext: {
    print($0)
}, onError: {
    print($0)
}, onCompleted: {
    print("completed")
}, onDisposed: {
    print("disposed")
})
.disposed(by: disposeBag)
  
// onCompleteted 호출 전까지 구독이 된다.
 
------create1------
1
completed
disposed

Reference

https://fastcampus.co.kr/dev_online_iosapp