Merge pull request #4 from PureSwift/feature/swiftui-containers

Add NavigationStack, TabView, sheet, refreshable, lazy stacks and Observation support

Author: colemancda

Sources/AndroidSwiftUI/AndroidNavigationStack.swift

@@ -0,0 +1,16 @@
+//
+//  AndroidNavigationStack.swift
+//  AndroidSwiftUI
+//
+//  Created by Alsey Coleman Miller on 7/21/26.
+//
+
+import AndroidKit
+
+extension NavigationStack: AndroidPrimitive {
+
+    var renderedBody: AnyView {
+        let proxy = _NavigationStackProxy(self)
+        return AnyView(AndroidNavigationContainer(context: proxy.context, currentView: proxy.currentView))
+    }
+}

Sources/AndroidSwiftUI/AndroidNavigationView.swift

@@ -10,21 +10,27 @@ import AndroidKit
 extension NavigationView: AndroidPrimitive {
 
     var renderedBody: AnyView {
-        AnyView(AndroidNavigationContainer(proxy: _NavigationViewProxy(self)))
+        let proxy = _NavigationViewProxy(self)
+        return AnyView(AndroidNavigationContainer(context: proxy.context, currentView: proxy.currentView))
     }
 }
 
-/// Native container for `NavigationView`. Hosts the currently visible screen (root content or the
-/// top of the navigation stack) as a mounted child, and intercepts the system back button to pop.
-struct AndroidNavigationContainer<Content: View> {
+/// Native container for `NavigationView` and `NavigationStack`. Hosts the currently visible screen
+/// (root content or the top of the navigation stack) as a mounted child, and intercepts the system
+/// back button to pop.
+struct AndroidNavigationContainer {
 
-    let proxy: _NavigationViewProxy<Content>
+    /// The navigation state shared with the `NavigationLink`s of the hosted screen.
+    let context: NavigationContext
+
+    /// The screen to display, provided by the container's proxy.
+    let currentView: AnyView
 }
 
 extension AndroidNavigationContainer: ParentView {
 
     var children: [AnyView] {
-        [proxy.currentView]
+        [currentView]
     }
 }
 
@@ -33,9 +39,9 @@ extension AndroidNavigationContainer: AndroidViewRepresentable {
     typealias Coordinator = Void
 
     func makeAndroidView(context: Self.Context) -> BackHandlerView {
-        let path = proxy.context
+        let navigationContext = self.context
         let view = BackHandlerView(context.androidContext) {
-            path.pop()
+            navigationContext.pop()
         }
         updateView(view)
         return view
@@ -49,6 +55,6 @@ extension AndroidNavigationContainer: AndroidViewRepresentable {
 private extension AndroidNavigationContainer {
 
     func updateView(_ view: BackHandlerView) {
-        view.setBackHandlerEnabled(!proxy.context.path.isEmpty)
+        view.setBackHandlerEnabled(!context.path.isEmpty)
     }
 }

Sources/AndroidSwiftUI/AndroidSheet.swift

@@ -0,0 +1,118 @@
+//
+//  AndroidSheet.swift
+//  AndroidSwiftUI
+//
+//  Created by Alsey Coleman Miller on 7/21/26.
+//
+
+import AndroidKit
+
+extension _SheetPresenter: AndroidPrimitive {
+
+    var renderedBody: AnyView {
+        AnyView(AndroidSheetContainer(presenter: self))
+    }
+}
+
+/// Native container for `.sheet(isPresented:onDismiss:content:)`.
+///
+/// The sheet is rendered as an overlay rather than an Android `Dialog`: the fiber renderer mounts
+/// children by adding them to their parent `ViewGroup`, so the presented content has to live in the
+/// same view hierarchy as the presenting content. `BackHandlerView` is a `FrameLayout`, so the sheet
+/// content is stacked on top of the host content and the system back button is intercepted while the
+/// sheet is presented.
+struct AndroidSheetContainer<Content: View> {
+
+    let presenter: _SheetPresenter<Content>
+}
+
+extension AndroidSheetContainer: ParentView {
+
+    var children: [AnyView] {
+        var views = [AnyView(presenter.content)]
+        if presenter.isSheetPresented {
+            views.append(AnyView(AndroidSheetOverlay(content: presenter.sheetContent())))
+        }
+        return views
+    }
+}
+
+extension AndroidSheetContainer: AndroidViewRepresentable {
+
+    typealias Coordinator = Void
+
+    func makeAndroidView(context: Self.Context) -> BackHandlerView {
+        let presenter = self.presenter
+        let view = BackHandlerView(context.androidContext) {
+            presenter.dismiss()
+        }
+        updateView(view)
+        return view
+    }
+
+    func updateAndroidView(_ view: BackHandlerView, context: Self.Context) {
+        updateView(view)
+    }
+}
+
+private extension AndroidSheetContainer {
+
+    func updateView(_ view: BackHandlerView) {
+        // only intercept the back button while the sheet is on screen
+        view.setBackHandlerEnabled(presenter.isSheetPresented)
+    }
+}
+
+/// Opaque, full size container for the presented sheet content, stacked above the presenting content.
+struct AndroidSheetOverlay {
+
+    let content: AnyView
+}
+
+extension AndroidSheetOverlay: ParentView {
+
+    var children: [AnyView] {
+        [content]
+    }
+}
+
+extension AndroidSheetOverlay: AndroidViewRepresentable {
+
+    typealias Coordinator = Void
+
+    func makeAndroidView(context: Self.Context) -> AndroidWidget.FrameLayout {
+        let androidContext = context.androidContext
+        let view = AndroidWidget.FrameLayout(androidContext)
+        let matchParent = try! JavaClass<ViewGroup.LayoutParams>().MATCH_PARENT
+        view.setLayoutParams(ViewGroup.LayoutParams(matchParent, matchParent))
+        view.setBackgroundColor(Self.backgroundColor(androidContext))
+        // swallow touches so the presenting content underneath is not interactive
+        view.setClickable(true)
+        view.setFocusable(true)
+        // draw above the presenting content
+        view.setElevation(16)
+        view.bringToFront()
+        return view
+    }
+
+    func updateAndroidView(_ view: AndroidWidget.FrameLayout, context: Self.Context) {
+        view.bringToFront()
+    }
+}
+
+private extension AndroidSheetOverlay {
+
+    /// The theme's window background, so the sheet is opaque in both light and dark themes.
+    static func backgroundColor(_ context: AndroidContent.Context) -> Int32 {
+        let opaqueWhite = Int32(bitPattern: 0xFF_FF_FF_FF)
+        guard let theme = context.getTheme() else {
+            return opaqueWhite
+        }
+        let value = AndroidUtil.TypedValue()
+        let attribute = try! JavaClass<AndroidR.R.attr>().colorBackground
+        guard theme.resolveAttribute(attribute, value, true) else {
+            return opaqueWhite
+        }
+        return value.data
+    }
+}

Sources/AndroidSwiftUI/AndroidTabView.swift

@@ -0,0 +1,193 @@
+//
+//  AndroidTabView.swift
+//  AndroidSwiftUI
+//
+//  Created by Alsey Coleman Miller on 7/21/26.
+//
+
+import AndroidKit
+
+extension TabView: AndroidPrimitive {
+
+    var renderedBody: AnyView {
+        AnyView(AndroidTabViewContainer(proxy: _TabViewProxy(self)))
+    }
+}
+
+/// Native container for `TabView`. A vertical `LinearLayout` that hosts the selected tab's content
+/// above a horizontal row of tab bar buttons.
+struct AndroidTabViewContainer<SelectionValue: Hashable, Content: View> {
+
+    let proxy: _TabViewProxy<SelectionValue, Content>
+}
+
+extension AndroidTabViewContainer: ParentView {
+
+    var children: [AnyView] {
+        let items = proxy.items
+        let selectedIndex = proxy.selectedIndex
+        // only the selected tab's content is mounted, hidden tabs are never rendered
+        let content = AndroidTabContent(content: proxy.selectedContent)
+        let bar = AndroidTabBar(
+            labels: items.enumerated().map { index, item in
+                item.label ?? AnyView(Text("Tab \(index + 1)"))
+            },
+            selectedIndex: selectedIndex,
+            select: { proxy.select($0) }
+        )
+        return [AnyView(content), AnyView(bar)]
+    }
+}
+
+extension AndroidTabViewContainer: AndroidViewRepresentable {
+
+    typealias Coordinator = Void
+
+    func makeAndroidView(context: Self.Context) -> AndroidWidget.LinearLayout {
+        let view = AndroidWidget.LinearLayout(context.androidContext)
+        view.orientation = .vertical
+        view.setLayoutParams(ViewGroup.LayoutParams(.matchParent, .matchParent))
+        return view
+    }
+
+    func updateAndroidView(_ view: AndroidWidget.LinearLayout, context: Self.Context) {
+
+    }
+}
+
+// MARK: - Content
+
+/// Hosts the selected tab's content, filling the space left over by the tab bar.
+///
+/// Deliberately non-generic so that switching tabs updates this container in place (instead of
+/// remounting it), which keeps the content above the tab bar in the parent `LinearLayout`.
+struct AndroidTabContent {
+
+    let content: AnyView
+}
+
+extension AndroidTabContent: ParentView {
+
+    var children: [AnyView] {
+        [content]
+    }
+}
+
+extension AndroidTabContent: AndroidViewRepresentable {
+
+    typealias Coordinator = Void
+
+    func makeAndroidView(context: Self.Context) -> AndroidWidget.LinearLayout {
+        let view = AndroidWidget.LinearLayout(context.androidContext)
+        view.orientation = .vertical
+        // fill the remaining vertical space
+        view.setLayoutParams(LinearLayout.LayoutParams(.matchParent, 0, 1).as(ViewGroup.LayoutParams.self))
+        return view
+    }
+
+    func updateAndroidView(_ view: AndroidWidget.LinearLayout, context: Self.Context) {
+
+    }
+}
+
+// MARK: - Tab Bar
+
+/// The row of tab bar buttons displayed at the bottom of a `TabView`.
+struct AndroidTabBar {
+
+    let labels: [AnyView]
+
+    let selectedIndex: Int
+
+    let select: (Int) -> ()
+}
+
+extension AndroidTabBar: ParentView {
+
+    var children: [AnyView] {
+        labels.enumerated().map { index, label in
+            AnyView(AndroidTabBarButton(
+                label: label,
+                isSelected: index == selectedIndex,
+                action: { select(index) }
+            ))
+        }
+    }
+}
+
+extension AndroidTabBar: AndroidViewRepresentable {
+
+    typealias Coordinator = Void
+
+    func makeAndroidView(context: Self.Context) -> AndroidWidget.LinearLayout {
+        let view = AndroidWidget.LinearLayout(context.androidContext)
+        view.orientation = .horizontal
+        view.gravity = .center
+        view.setLayoutParams(LinearLayout.LayoutParams(.matchParent, .wrapContent, 0).as(ViewGroup.LayoutParams.self))
+        return view
+    }
+
+    func updateAndroidView(_ view: AndroidWidget.LinearLayout, context: Self.Context) {
+
+    }
+}
+
+/// A single tab bar button, hosting its `tabItem(_:)` label as a mounted child.
+struct AndroidTabBarButton {
+
+    let label: AnyView
+
+    let isSelected: Bool
+
+    let action: () -> ()
+}
+
+extension AndroidTabBarButton: ParentView {
+
+    var children: [AnyView] {
+        [label]
+    }
+}
+
+extension AndroidTabBarButton: AndroidViewRepresentable {
+
+    typealias Coordinator = Void
+
+    func makeAndroidView(context: Self.Context) -> AndroidWidget.LinearLayout {
+        let view = AndroidWidget.LinearLayout(context.androidContext)
+        view.orientation = .vertical
+        view.gravity = .center
+        // every tab occupies an equal share of the tab bar
+        view.setLayoutParams(LinearLayout.LayoutParams(0, .wrapContent, 1).as(ViewGroup.LayoutParams.self))
+        view.setClickable(true)
+        updateView(view)
+        return view
+    }
+
+    func updateAndroidView(_ view: AndroidWidget.LinearLayout, context: Self.Context) {
+        updateView(view)
+    }
+}
+
+private extension AndroidTabBarButton {
+
+    func updateView(_ view: AndroidWidget.LinearLayout) {
+        // the listener captures the current selection, so it has to be replaced on every update
+        let listener = ViewOnClickListener(action: action)
+        view.setOnClickListener(listener.as(AndroidView.View.OnClickListener.self))
+        view.setAlpha(isSelected ? 1.0 : 0.5)
+    }
+}
+
+// MARK: - Layout Params
+
+internal extension Int32 {
+
+    static var matchParent: Int32 {
+        try! JavaClass<ViewGroup.LayoutParams>().MATCH_PARENT
+    }
+
+    static var wrapContent: Int32 {
+        try! JavaClass<ViewGroup.LayoutParams>().WRAP_CONTENT
+    }
+}