✨[feat]: 화면 전환 방식 변경 #13

* 스플래쉬에서 화면 전환 변경하는 로직 추가
DDD-Community · Oct 2, 2024 · cf211b4 · cf211b4
1 parent 7f7a06a
commit cf211b4
Show file tree

Hide file tree

Showing 4 changed files with 202 additions and 17 deletions.
diff --git a/OPeace/Projects/App/Sources/Reducer/AppReducer.swift b/OPeace/Projects/App/Sources/Reducer/AppReducer.swift
@@ -19,7 +19,8 @@ public struct AppReducer {
     @ObservableState
     public enum State {
         case splash(Splash.State)
-        case root(Root.State)
+        case auth(AuthCoordinator.State)
+        case main(HomeCoordinator.State)
 
 
         public init() {
@@ -42,8 +43,10 @@ public struct AppReducer {
     public enum View {
         case presntView
         case presentRootView
+        case presntAuthView
         case splash(Splash.Action)
-        case root(Root.Action)
+        case auth(AuthCoordinator.Action)
+        case main(HomeCoordinator.Action)
     }
 
     //MARK: - 앱내에서 사용하는 액선
@@ -70,15 +73,47 @@ public struct AppReducer {
                 switch View {
 
                 case .presntView:
-                    return .run { @MainActor send in
+                    return .run { send in
+                        await send(.view(.splash(.async(.checkUserVerfiy))))
+                    }
+
+                case .splash(.navigation(.presntMain)):
+                    return .run { send in
                         try await self.clock.sleep(for: .seconds(4))
-                         send(.view(.splash(.presentRootView)), animation: .easeOut(duration: 1))
-                        send(.view(.presentRootView))
+                        await send(.view(.presentRootView))
                     }
 
+                case .splash(.navigation(.presntLogin)):
+                    return .run { send in
+                        try await self.clock.sleep(for: .seconds(4))
+                        await send(.view(.presntAuthView))
+                    }
+
+                case .auth(.navigation(.presntMainHome)):
+                    return .send(.view(.presentRootView))
+
+                case .main(.navigation(.presntAuth)):
+                    return .send(.view(.presntAuthView))
+
+                case .auth(.login(.navigation(.presentMain))):
+                    return .send(.view(.presentRootView))
+
+                case .auth(.login(.navigation(.presntLookAround))):
+                    return .send(.view(.presentRootView))
+
+                case .auth(.completeSignUp(.navigation(.presntMainHome))):
+                    return .send(.view(.presentRootView))
+
+                case .auth(.onBoarding(.navigation(.presntMainHome))):
+                    return .send(.view(.presentRootView))
+
+
                 case .presentRootView:
-                    state = .root(.init())
-//                    state = .root(.init())
+                    state = .main(.init())
+                    return .none
+
+                case .presntAuthView:
+                    state = .auth(.init())
                     return .none
 
                 default:
@@ -105,8 +140,11 @@ public struct AppReducer {
         .ifCaseLet(\.splash, action: \.view.splash) {
             Splash()
         }
-        .ifCaseLet(\.root, action: \.view.root) {
-            Root()
+        .ifCaseLet(\.auth, action: \.view.auth){
+            AuthCoordinator()
+        }
+        .ifCaseLet(\.main, action: \.view.main) {
+            HomeCoordinator()
         }
     }
 }

diff --git a/OPeace/Projects/App/Sources/View/AppView.swift b/OPeace/Projects/App/Sources/View/AppView.swift
@@ -20,14 +20,18 @@ public struct AppView: View {
                 if let store = store.scope(state: \.splash, action: \.view.splash) {
                     SplashView(store: store)
                 }
+
+            case .auth:
+                if let store = store.scope(state: \.auth, action: \.view.auth) {
+                    AuthView(store: store)
+                }
 
 
-            case .root:
-                if let store = store.scope(state: \.root, action: \.view.root) {
-                    RootView(store: store)
+            case .main:
+                if let store = store.scope(state: \.main, action: \.view.main) {
+                    HomeCoordinatorView(store: store)
                 }
             }
-
         }
         .onAppear {
             store.send(.view(.presntView))

diff --git a/OPeace/Projects/Presentation/Presentation/Sources/Splash/Reducer/Splash.swift b/OPeace/Projects/Presentation/Presentation/Sources/Splash/Reducer/Splash.swift
@@ -9,6 +9,12 @@ import Foundation
 import ComposableArchitecture
 import DesignSystem
 
+import Utills
+import UseCase
+import Model
+
+import Utill
+
 @Reducer
 public struct Splash {
     public init() {}
@@ -18,17 +24,151 @@ public struct Splash {
         public init() {}
         var applogoImage: ImageAsset = .spalshLogo
         var backgroundmage: ImageAsset = .backGroud
+
+        var checkUserVerifyModel: CheckUserVerifyModel? = nil
+        var refreshTokenModel: RefreshModel? = nil
+
+    }
+
+    public enum Action: ViewAction, BindableAction, FeatureAction {
+        case binding(BindingAction<State>)
+        case view(View)
+        case async(AsyncAction)
+        case inner(InnerAction)
+        case navigation(NavigationAction)
+    }
+
+    //MARK: - ViewAction
+    @CasePathable
+    public enum View {
+
+    }
+
+
+
+    //MARK: - AsyncAction 비동기 처리 액션
+    public enum AsyncAction: Equatable {
+        case refreshTokenResponse(Result<RefreshModel, CustomError>)
+        case refreshTokenRequest(refreshToken: String)
+
+        case checkUserVerfiy
+        case checkUserVerfiyResponse(Result<CheckUserVerifyModel , CustomError>)
     }
 
-    public enum Action: Equatable {
-        case presentRootView
+    //MARK: - 앱내에서 사용하는 액션
+    public enum InnerAction: Equatable {
+
     }
 
+    //MARK: - NavigationAction
+    public enum NavigationAction: Equatable {
+        case presntMain
+        case presntLogin
+    }
+
+    @Dependency(AuthUseCase.self) var authUseCase
+    @Dependency(\.continuousClock) var clock
+
     public var body: some ReducerOf<Self> {
-        Reduce { state, action in
+        BindingReducer()
+        Reduce {
+            state,
+            action in
             switch action {
-            case .presentRootView:
+            case .binding(_):
                 return .none
+
+
+            case .view(let View):
+                switch View {
+
+                }
+
+            case .async(let AsyncAction):
+                switch AsyncAction {
+                case .refreshTokenRequest(let refreshToken):
+                    return .run { send in
+                        let refreshTokenResult = await Result {
+                            try await authUseCase.requestRefreshToken(refreshToken: refreshToken)
+                        }
+
+                        switch refreshTokenResult {
+                        case .success(let refreshTokenData):
+                            if let refreshTokenData = refreshTokenData {
+                                await send(.async(.refreshTokenResponse(.success(refreshTokenData))))
+
+                                if refreshTokenData.data?.refreshToken?.isEmpty != nil && refreshTokenData.data?.accessToken?.isEmpty != nil {
+                                    await send(.navigation(.presntMain))
+                                }
+                            }
+
+                        case .failure(let error):
+                            await send(.async(.refreshTokenResponse(.failure(CustomError.tokenError(error.localizedDescription)))))
+                        }
+                    }
+
+                case .refreshTokenResponse(let result):
+                    switch result {
+                    case .success(let refreshTokenData):
+                        state.refreshTokenModel = refreshTokenData
+                        UserDefaults.standard.set(state.refreshTokenModel?.data?.refreshToken ?? "", forKey: "REFRESH_TOKEN")
+                        UserDefaults.standard.set(state.refreshTokenModel?.data?.accessToken ?? "", forKey: "ACCESS_TOKEN")
+                    case .failure(let error):
+                        Log.error("토큰 재발급 실패", error.localizedDescription)
+                    }
+                    return .none
+
+
+                case .checkUserVerfiy:
+                    return .run { send in
+                        let checkUserVerifyResult = await Result {
+                            try await authUseCase.checkUserVerify()
+                        }
+
+                        switch checkUserVerifyResult {
+                        case .success(let checkUserVerifyData):
+                            if let checkUserVerifyData = checkUserVerifyData {
+                                await send(.async(.checkUserVerfiyResponse(.success(checkUserVerifyData))))
+
+                                if checkUserVerifyData.data?.status == true {
+                                    await send(.navigation(.presntMain))
+                                } else {
+                                    let refreshToken = UserDefaults.standard.string(forKey: "REFRESH_TOKEN") ?? ""
+                                    await send(.async(.refreshTokenRequest(refreshToken: refreshToken)))
+
+                                }
+                            }
+                        case .failure(let error):
+                            await send(.async(.checkUserVerfiyResponse(.failure(CustomError.tokenError(error.localizedDescription)))))
+
+                            await send(.navigation(.presntLogin))
+
+                        }
+                    }
+
+                case .checkUserVerfiyResponse(let result):
+                    switch result {
+                    case .success(let userVerifyData):
+                        state.checkUserVerifyModel = userVerifyData
+                    case .failure(let error):
+                        Log.error("토큰 재발급 실패", error.localizedDescription)
+                    }
+                    return .none
+                }
+
+            case .inner(let InnerAction):
+                switch InnerAction {
+
+                }
+
+            case .navigation(let NavigationAction):
+                switch NavigationAction {
+                case .presntMain:
+                    return .none
+
+                case .presntLogin:
+                    return .none
+                }
             }
         }
     }

diff --git a/OPeace/Projects/Presentation/Presentation/Sources/Splash/View/SplashView.swift b/OPeace/Projects/Presentation/Presentation/Sources/Splash/View/SplashView.swift
@@ -33,6 +33,9 @@ public struct SplashView: View {
                 .frame(height: 48)
 
         }
+        .onAppear {
+            store.send(.async(.checkUserVerfiy))
+        }
     }
 }