marshroute

MarshrouteFacade.swift
386 строк · 16.8 Кб
Перенос по словам
1
import Marshroute
2
import UIKit
3

4
final class MarshrouteFacade {
5
    // MARK: - Private properties
6
    let marshrouteStack: MarshrouteStack
7
    
8
    // MARK: - Init
9
    init(marshrouteSetupService: MarshrouteSetupService = MarshrouteSetupServiceImpl()) {
10
        self.marshrouteStack = marshrouteSetupService.marshrouteStack()
11
    }
12
    
13
    init(marshrouteStack: MarshrouteStack) {
14
        self.marshrouteStack = marshrouteStack
15
    }
16
    
17
    func navigationModule(
18
        _ navigationController: UINavigationController? = nil,
19
        withRootViewControllerDerivedFrom deriveViewController: (RouterSeed) -> (UIViewController))
20
        -> (UINavigationController, UIViewController, BaseRouter)
21
    {
22
        let transitionId = marshrouteStack.transitionIdGenerator.generateNewTransitionId()
23
        
24
        let navigationController = navigationController ?? marshrouteStack.routerControllersProvider.navigationController()
25
        
26
        let navigationTransitionsHandler = marshrouteStack.transitionsHandlersProvider.navigationTransitionsHandler(
27
            navigationController: navigationController
28
        )
29
        
30
        let routerSeed = RouterSeed(
31
            transitionsHandlerBox: .init(animatingTransitionsHandler: navigationTransitionsHandler),
32
            transitionId: transitionId,
33
            presentingTransitionsHandler: nil,
34
            transitionsHandlersProvider: marshrouteStack.transitionsHandlersProvider,
35
            transitionIdGenerator: marshrouteStack.transitionIdGenerator,
36
            controllersProvider: marshrouteStack.routerControllersProvider,
37
            routerTransitionDelegate: nil
38
        )
39
        
40
        let viewController = deriveViewController(routerSeed)
41
        
42
        let resetContext = ResettingTransitionContext(
43
            settingRootViewController: viewController,
44
            forNavigationController: navigationController,
45
            navigationTransitionsHandler: navigationTransitionsHandler,
46
            animator: SetNavigationTransitionsAnimator(),
47
            transitionId: transitionId
48
        )
49
        
50
        navigationTransitionsHandler.resetWithTransition(
51
            context: resetContext
52
        )
53
        
54
        return (
55
            navigationController,
56
            viewController,
57
            BaseRouter(routerSeed: routerSeed)
58
        )
59
    }
60
    
61
    func tabBarController(
62
        _ tabBarController: (TabBarControllerProtocol & UIViewController)? = nil,
63
        tabControllerDeriviationFunctionTypes: [TabControllerDeriviationFunctionType])
64
        -> (TabBarControllerProtocol & UIViewController)
65
    {
66
        // MARK: - Preimplementation
67
        let transitionId = marshrouteStack.transitionIdGenerator.generateNewTransitionId()
68
        
69
        // MARK: - Helpers
70
        func makeRouterSeed(transitionsHandlerBox: TransitionsHandlerBox)
71
            -> RouterSeed
72
        {
73
            return RouterSeed(
74
                transitionsHandlerBox: transitionsHandlerBox,
75
                transitionId: transitionId,
76
                presentingTransitionsHandler: nil,
77
                transitionsHandlersProvider: marshrouteStack.transitionsHandlersProvider,
78
                transitionIdGenerator: marshrouteStack.transitionIdGenerator,
79
                controllersProvider: marshrouteStack.routerControllersProvider,
80
                routerTransitionDelegate: nil
81
            )
82
        }
83
        
84
        func deriveDetailController(
85
            tabIndex: Int,
86
            detailControllerDeriviationFunctionType: DetailControllerDeriviationFunctionType)
87
            -> (UIViewController, AnimatingTransitionsHandler)
88
        {
89
            switch detailControllerDeriviationFunctionType {
90
            case .controller(let detailControllerDeriviationFuction):
91
                return deriveDetailController(
92
                    tabIndex: tabIndex,
93
                    detailControllerDeriviationFuction: detailControllerDeriviationFuction
94
                )
95
                
96
            case .controllerInNavigationController(let detailControllerDeriviationFuction):
97
                return deriveDetailControllerInNavigationController(
98
                    tabIndex: tabIndex,
99
                    detailControllerDeriviationFuction: detailControllerDeriviationFuction
100
                )
101
            }
102
        }
103
        
104
        func deriveDetailController(
105
            tabIndex: Int,
106
            detailControllerDeriviationFuction: DetailControllerDeriviationFuction)
107
            -> (UIViewController, AnimatingTransitionsHandler)
108
        {
109
            let animatingTransitionsHandler = marshrouteStack.transitionsHandlersProvider.animatingTransitionsHandler()
110
            
111
            let routerSeed = makeRouterSeed(
112
                transitionsHandlerBox: .init(animatingTransitionsHandler: animatingTransitionsHandler)
113
            )
114
            
115
            let controllerDeriviationParams = DetailControllerDeriviationParams(
116
                tabIndex: tabIndex,
117
                routerSeed: routerSeed
118
            )
119
            
120
            let viewController = detailControllerDeriviationFuction.deriveController(controllerDeriviationParams)
121
            
122
            let resetContext = ResettingTransitionContext(
123
                registeringViewController: viewController,
124
                animatingTransitionsHandler: animatingTransitionsHandler,
125
                transitionId: transitionId
126
            )
127
            
128
            animatingTransitionsHandler.resetWithTransition(context: resetContext)
129
            
130
            return (viewController, animatingTransitionsHandler)
131
        }
132
        
133
        func deriveDetailControllerInNavigationController(
134
            tabIndex: Int,
135
            detailControllerDeriviationFuction: DetailControllerDeriviationFuction)
136
            -> (UIViewController, AnimatingTransitionsHandler)
137
        {
138
            let navigationController = marshrouteStack.routerControllersProvider.navigationController()
139
            
140
            let navigationTransitionsHandler = marshrouteStack.transitionsHandlersProvider.navigationTransitionsHandler(
141
                navigationController: navigationController
142
            )
143
            
144
            let routerSeed = makeRouterSeed(
145
                transitionsHandlerBox: .init(animatingTransitionsHandler: navigationTransitionsHandler)
146
            )
147
            
148
            let controllerDeriviationParams = DetailControllerDeriviationParams(
149
                tabIndex: tabIndex,
150
                routerSeed: routerSeed
151
            )
152
            
153
            let viewController = detailControllerDeriviationFuction.deriveController(controllerDeriviationParams)
154
            
155
            let resetContext = ResettingTransitionContext(
156
                settingRootViewController: viewController,
157
                forNavigationController: navigationController,
158
                navigationTransitionsHandler: navigationTransitionsHandler,
159
                animator: SetNavigationTransitionsAnimator(),
160
                transitionId: transitionId
161
            )
162
            
163
            navigationTransitionsHandler.resetWithTransition(
164
                context: resetContext
165
            )
166
            
167
            return (viewController, navigationTransitionsHandler)
168
        }
169
        
170
        // MARK: - MasterDetail helpers
171
    
172
        func makeMasterDetailRouterSeed(
173
            masterTransitionsHandlerBox: TransitionsHandlerBox,
174
            detailTransitionsHandlerBox: TransitionsHandlerBox)
175
            -> MasterDetailRouterSeed
176
        {
177
            return MasterDetailRouterSeed(
178
                masterTransitionsHandlerBox: masterTransitionsHandlerBox,
179
                detailTransitionsHandlerBox: detailTransitionsHandlerBox,
180
                transitionId: transitionId,
181
                presentingTransitionsHandler: nil,
182
                transitionsHandlersProvider: marshrouteStack.transitionsHandlersProvider,
183
                transitionIdGenerator: marshrouteStack.transitionIdGenerator,
184
                controllersProvider: marshrouteStack.routerControllersProvider,
185
                routerTransitionDelegate: nil
186
            )
187
        }
188
        
189
        func deriveMasterController(
190
            tabIndex: Int,
191
            detailTransitionsHandlerBox: TransitionsHandlerBox,
192
            masterControllerDeriviationFunctionType: MasterControllerDeriviationFunctionType)
193
            -> (UIViewController, AnimatingTransitionsHandler)
194
        {
195
            switch masterControllerDeriviationFunctionType {
196
            case .controller(let masterControllerDeriviationFuction):
197
                return deriveMasterController(
198
                    tabIndex: tabIndex,
199
                    detailTransitionsHandlerBox: detailTransitionsHandlerBox,
200
                    masterControllerDeriviationFuction: masterControllerDeriviationFuction
201
                )
202
                
203
            case .controllerInNavigationController(let masterControllerDeriviationFuction):
204
                return deriveMasterControllerInNavigationController(
205
                    tabIndex: tabIndex,
206
                    detailTransitionsHandlerBox: detailTransitionsHandlerBox,
207
                    masterControllerDeriviationFuction: masterControllerDeriviationFuction
208
                )
209
            }
210
        }
211
        
212
        func deriveMasterController(
213
            tabIndex: Int,
214
            detailTransitionsHandlerBox: TransitionsHandlerBox,
215
            masterControllerDeriviationFuction: MasterControllerDeriviationFunction)
216
            -> (UIViewController, AnimatingTransitionsHandler)
217
        {
218
            let animatingTransitionsHandler = marshrouteStack.transitionsHandlersProvider.animatingTransitionsHandler()
219
            
220
            let routerSeed = makeMasterDetailRouterSeed(
221
                masterTransitionsHandlerBox: .init(animatingTransitionsHandler: animatingTransitionsHandler),
222
                detailTransitionsHandlerBox: detailTransitionsHandlerBox
223
            )
224
            
225
            let controllerDeriviationParams = MasterControllerDeriviationParams(
226
                tabIndex: tabIndex,
227
                routerSeed: routerSeed
228
            )
229
            
230
            let viewController = masterControllerDeriviationFuction.deriveController(controllerDeriviationParams)
231
            
232
            let resetContext = ResettingTransitionContext(
233
                registeringViewController: viewController,
234
                animatingTransitionsHandler: animatingTransitionsHandler,
235
                transitionId: transitionId
236
            )
237
            
238
            animatingTransitionsHandler.resetWithTransition(context: resetContext)
239
            
240
            return (viewController, animatingTransitionsHandler)
241
        }
242
        
243
        func deriveMasterControllerInNavigationController(
244
            tabIndex: Int,
245
            detailTransitionsHandlerBox: TransitionsHandlerBox,
246
            masterControllerDeriviationFuction: MasterControllerDeriviationFunction)
247
            -> (UIViewController, AnimatingTransitionsHandler)
248
        {
249
            let navigationController = marshrouteStack.routerControllersProvider.navigationController()
250
            
251
            let navigationTransitionsHandler = marshrouteStack.transitionsHandlersProvider.navigationTransitionsHandler(
252
                navigationController: navigationController
253
            )
254
            
255
            let routerSeed = makeMasterDetailRouterSeed(
256
                masterTransitionsHandlerBox: .init(animatingTransitionsHandler: navigationTransitionsHandler),
257
                detailTransitionsHandlerBox: detailTransitionsHandlerBox
258
            )
259
            
260
            let controllerDeriviationParams = MasterControllerDeriviationParams(
261
                tabIndex: tabIndex,
262
                routerSeed: routerSeed
263
            )
264
            
265
            let viewController = masterControllerDeriviationFuction.deriveController(controllerDeriviationParams)
266
            
267
            let resetContext = ResettingTransitionContext(
268
                settingRootViewController: viewController,
269
                forNavigationController: navigationController,
270
                navigationTransitionsHandler: navigationTransitionsHandler,
271
                animator: SetNavigationTransitionsAnimator(),
272
                transitionId: transitionId
273
            )
274
            
275
            navigationTransitionsHandler.resetWithTransition(
276
                context: resetContext
277
            )
278
            
279
            return (viewController, navigationTransitionsHandler)
280
        }
281

282
        func deriveMasterDetailController(
283
            tabIndex: Int,
284
            masterDetailControllerDeriviationFuctionTypes: MasterDetailControllerDeriviationFuctionTypes)
285
            -> (SplitViewControllerProtocol & UIViewController, SplitViewTransitionsHandler)
286
        {
287
            let (detailController, detaillTransitionHandler) = deriveDetailController(
288
                tabIndex: tabIndex,
289
                detailControllerDeriviationFunctionType: masterDetailControllerDeriviationFuctionTypes.detailFunctionType
290
            )
291
            
292
            let (masterController, masterTransitionsHandler) = deriveMasterController(
293
                tabIndex: tabIndex,
294
                detailTransitionsHandlerBox: .init(animatingTransitionsHandler: detaillTransitionHandler),
295
                masterControllerDeriviationFunctionType: masterDetailControllerDeriviationFuctionTypes.masterFunctionType
296
            )
297
            
298
            let splitViewController = marshrouteStack.routerControllersProvider.splitViewController()
299
            
300
            splitViewController.viewControllers = [masterController, detailController]
301
            
302
            let splitTransitionsHandler = marshrouteStack.transitionsHandlersProvider.splitViewTransitionsHandler(
303
                splitViewController: splitViewController
304
            )
305
            
306
            splitTransitionsHandler.masterTransitionsHandler = masterTransitionsHandler
307
            splitTransitionsHandler.detailTransitionsHandler = detaillTransitionHandler
308
            
309
            return (splitViewController, splitTransitionsHandler)
310
        }
311

312
        // MARK: - Implementation
313
        let tabBarController = tabBarController ?? UITabBarController()
314
        
315
        let tabTransitionsHandler = marshrouteStack.transitionsHandlersProvider.tabBarTransitionsHandler(
316
            tabBarController: tabBarController
317
        )
318
        
319
        var animatingTransitionsHandlers = [Int: AnimatingTransitionsHandler]()
320
        var containingTransitionsHandlers = [Int: ContainingTransitionsHandler]()
321
        var tabControllers = [UIViewController]()
322
        
323
        for (tabIndex, deriviationFunctionType) in tabControllerDeriviationFunctionTypes.enumerated() {
324
            switch deriviationFunctionType {
325
            case .controller(let detailControllerDeriviationFunctionType):
326
                let (viewController, animatingTransitionsHandler) = deriveDetailController(
327
                    tabIndex: tabIndex,
328
                    detailControllerDeriviationFunctionType: detailControllerDeriviationFunctionType
329
                )
330
                tabControllers.append(viewController)
331
                animatingTransitionsHandlers[tabIndex] = animatingTransitionsHandler
332
                
333
            case .masterDetailController(let masterDetailControllerDeriviationFuctionTypes):
334
                let (viewController, containingTransitionsHandler) = deriveMasterDetailController(
335
                    tabIndex: tabIndex,
336
                    masterDetailControllerDeriviationFuctionTypes: masterDetailControllerDeriviationFuctionTypes
337
                )
338
                tabControllers.append(viewController)
339
                containingTransitionsHandlers[tabIndex] = containingTransitionsHandler
340
            }
341
        }
342
        
343
        tabTransitionsHandler.animatingTransitionsHandlers = animatingTransitionsHandlers
344
        tabTransitionsHandler.containingTransitionsHandlers = containingTransitionsHandlers
345
        
346
        return tabBarController
347
    }
348
}
349

350
struct DetailControllerDeriviationParams {
351
    let tabIndex: Int
352
    let routerSeed: RouterSeed
353
}
354

355
struct DetailControllerDeriviationFuction {
356
    let deriveController: ((DetailControllerDeriviationParams) -> (UIViewController))
357
}
358

359
enum DetailControllerDeriviationFunctionType {
360
    case controller(DetailControllerDeriviationFuction)
361
    case controllerInNavigationController(DetailControllerDeriviationFuction)
362
}
363

364
struct MasterControllerDeriviationParams {
365
    let tabIndex: Int
366
    let routerSeed: MasterDetailRouterSeed
367
}
368

369
struct MasterControllerDeriviationFunction {
370
    let deriveController: ((MasterControllerDeriviationParams) -> (UIViewController))
371
}
372

373
enum MasterControllerDeriviationFunctionType {
374
    case controller(MasterControllerDeriviationFunction)
375
    case controllerInNavigationController(MasterControllerDeriviationFunction)
376
}
377

378
struct MasterDetailControllerDeriviationFuctionTypes {
379
    let masterFunctionType: MasterControllerDeriviationFunctionType
380
    let detailFunctionType: DetailControllerDeriviationFunctionType
381
}
382

383
enum TabControllerDeriviationFunctionType {
384
    case controller(DetailControllerDeriviationFunctionType)
385
    case masterDetailController(MasterDetailControllerDeriviationFuctionTypes)
386
}
387
marshroute

Использование cookies
