← Granite (SwiftUI)

GraniteNavigation.Router

Swift
public final class GraniteNavigation: ObservableObject {
    
    public struct Router {
        public let id: String
        public init(id: String) {
            self.id = id
        }
        
        public var navigation: GraniteNavigation {
            GraniteNavigation.instance(for: id)
        }
        
        public func push<C: View>(style: GraniteNavigationDestinationStyle = .init(),
                                  window: GraniteRouteWindowProperties? = nil,
                                  @ViewBuilder _ content: @escaping () -> C) {
            self.navigation.push(destinationStyle: style,
                                 window: window,
                                 content)
        }
        
        public func push<C: GraniteNavigationDestination>(window: GraniteRouteWindowProperties? = nil,
                                                          @ViewBuilder _ content: @escaping () -> C) {
            self.navigation.push(window: window,
                                 content)
        }
        
        public func pop() {
            self.navigation.pop()
        }
    }

  ...

}

Il s’agit essentiellement du routeur principal exposé aux Views de votre application sous forme d’EnvironmentValues, qui vous permet de pousser et de retirer librement des vues par programmation, partout où il est disponible.

Swift
struct PostCardView: View {
    @Environment(\.graniteRouter) var router

    ...

    var body: some View {
        Button {
           router.push {
               PostDisplayView(context: _context,
                               updatedModel: currentModel)
           }
        } label: {
            Text("Push")
        }

        SomeView()
            .route {
                PostDisplayView(context: _context,
                                updatedModel: currentModel)
            } with: { router }
    }
}

C’est aussi simple que cela. Plusieurs extensions de vue sont disponibles pour accéder facilement aux fonctions de routage, ou vous pouvez simplement appeler push ou pop directement pour les exécuter. Et la View ou le GraniteComponent capturé glissera par-dessus l’appelant.

Swift
self.navigation.push(window: window, content)

La struct Router retrouve l’instance de GraniteNavigation qui la représente pour utiliser ses fonctions push/pop.

Swift
public extension GraniteNavigation {
    func push<Component: View>(destinationStyle style: GraniteNavigationDestinationStyle = .init(),
                               window: GraniteRouteWindowProperties? = nil,
                               @ViewBuilder _ component: @escaping (() -> Component)) {
        
        let component = NavigationComponent<Component>(component)
        
        let memadd = self.set(destinationStyle: style) {
            component
        }
        
        self.push(memadd, window: window)
    }
}

L’extension elle-même enveloppe le composant dans un NavigationComponent, définit le composant et renvoie une adresse de heap pour cibler le push le moment venu.

Swift
public func routeButton<C: GraniteNavigationDestination>(title: String = "",
                                                         window: GraniteRouteWindowProperties? = nil,
                                                         @ViewBuilder component : @escaping (() -> C),
                                                             with router: @escaping (() -> GraniteNavigation.Router)) -> some View {
        
    let router = router()
    let memadd = router.navigation.set {
        NavigationComponent<C>(component)
    }
    
    return Button {
        #if os(iOS)
        UIImpactFeedbackGenerator(style: .light).impactOccurred()
        #endif
        router.navigation.push(memadd, window: window)
    } label: {
        self
    }
}

set est séparé de push pour les cas où nous voulons qu’une condition survienne avant de pousser, mais où nous voulons tout de même définir le composant pour un temps de présentation optimal.

Les extensions de vue ci-dessus permettent simplement une écriture plus propre dans un builder var body: some View d’une View standard. En théorie, vous pouvez simplement utiliser le routeur directement pour toute une application.

Un extrait réel de la fonction set de GraniteNavigation appelée ci-dessus.

Swift
func set<Component : GraniteComponent>(destinationStyle: GraniteNavigationDestinationStyle = .init(),
                                           @ViewBuilder _ component: @escaping (() -> Component)) -> String {
        
    let screen = NavigationPassthroughComponent<Component, EmptyGranitePayload>.Screen<Component, EmptyGranitePayload>.init(component)
    let addr = NSString(format: "%p", addressHeap(o: screen)) as String
    
    paths[addr] = { AnyView(NavigationPassthroughComponent<Component,
                            EmptyGranitePayload>(screen: screen)
        .environment(\.graniteNavigationDestinationStyle, destinationStyle)) }
    
    isActive[addr] = false
    return addr
}

L’écran est important pour définir GraniteNavigationDestinationStyle, grâce auquel les vues qui présentent peuvent, de votre côté, personnaliser les éléments de la barre de navigation de fin et d’autres propriétés. Il aide aussi à gérer le cycle de vie de la présentation et à animer les « segues ».