ios - UICollectionView 和 SwiftUI？

Question

如何使用 SwiftUI 创建方形项目网格（例如在 iOS 照片库中）？

我尝试了这种方法，但它不起作用：

var body: some View {
    List(cellModels) { _ in
        Color.orange.frame(width: 100, height: 100)
    }
}

List 仍然具有 UITableView 样式：

score 35 · Accepted Answer

iOS 14 和 XCode 12

适用于 iOS 14 的 SwiftUI 带来了一个易于使用的全新原生网格视图，名为LazyVGrid： https ://developer.apple.com/documentation/swiftui/lazyvgrid

您可以从定义GridItem 的数组开始。GridItems 用于指定每一列的布局属性。在这种情况下，所有 GridItem 都是灵活的。

LazyVGrid 将 GridItem 的数组作为其参数，并根据定义的 GridItem 显示包含视图。

import SwiftUI

struct ContentView: View {
    
    let columns = [
        GridItem(.flexible()),
        GridItem(.flexible()),
        GridItem(.flexible()),
        GridItem(.flexible())
    ]
    
    var body: some View {
        ScrollView {
            LazyVGrid(columns: columns) {
                ForEach(0...100, id: \.self) { _ in
                    Color.orange.frame(width: 100, height: 100)
                }
            }
        }
    }
}

score 32 · Accepted Answer

一种可能的解决方案是将您包装UICollectionView成UIViewRepresentable. 请参阅组合和创建视图SwiftUI 教程，其中将它们包装MKMapView为示例。

到目前为止UICollectionView，SwiftUI 中还没有等价物，也没有计划。查看该推文下的讨论。

要获取更多详细信息，请查看集成 SwiftUI WWDC 视频 (~8:08)。

更新：

从 iOS 14 (beta) 开始，我们Lazy*Stack至少可以使用 SwiftUI 来实现集合视图的性能。当谈到单元格的布局时，我认为我们仍然必须在每行/每列的基础上手动管理它。

score 26 · Accepted Answer

QGrid是我创建的一个小型库，它使用与 SwiftUIList视图相同的方法，通过从底层识别数据集合中按需计算其单元格：

假设您已经有一个自定义单元格视图，QGrid则可以在最简单的形式中与您的正文中的这 1 行代码一起使用：View

struct PeopleView: View {
  var body: some View {
    QGrid(Storage.people, columns: 3) { GridCell(person: $0) }
  }
}   

struct GridCell: View {
  var person: Person
  var body: some View {
    VStack() {
      Image(person.imageName).resizable().scaledToFit()
      Text(person.firstName).font(.headline).color(.white)
      Text(person.lastName).font(.headline).color(.white)
    }
  }
}

您还可以自定义默认布局配置：

struct PeopleView: View {
  var body: some View {
    QGrid(Storage.people,
          columns: 3,
          columnsInLandscape: 4,
          vSpacing: 50,
          hSpacing: 20,
          vPadding: 100,
          hPadding: 20) { person in
            GridCell(person: person)
    }
  }
}

请参考 GitHub 存储库中的演示 GIF 和测试应用程序：

https://github.com/Q-Mobile/QGrid

score 24 · Accepted Answer

在 SwiftUI 中思考，有一个简单的方法：

struct MyGridView : View {
var body: some View {
    List() {
        ForEach(0..<8) { _ in
            HStack {
                ForEach(0..<3) { _ in
                    Image("orange_color")
                        .resizable()
                        .scaledToFit()
                }
            }
        }
    }
}

}

如果你愿意，SwiftUI 就足够了，有时你需要忘记 UIColectionView 之类的......

score 9 · Accepted Answer

XCode 11.0

在寻找了一段时间后，我决定我想要 UICollectionView 的所有便利和性能。所以我实现了UIViewRepresentable协议。

data: [Int]此示例未实现 DataSource，并且在集合视图上有一个虚拟字段。当数据更改时，您将使用@Bindable var data: [YourData]onAlbumGridView自动重新加载您的视图。

AlbumGridView然后可以像 SwiftUI 中的任何其他视图一样使用。

代码

class AlbumPrivateCell: UICollectionViewCell {
    private static let reuseId = "AlbumPrivateCell"

    static func registerWithCollectionView(collectionView: UICollectionView) {
        collectionView.register(AlbumPrivateCell.self, forCellWithReuseIdentifier: reuseId)
    }

    static func getReusedCellFrom(collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> AlbumPrivateCell{
        return collectionView.dequeueReusableCell(withReuseIdentifier: reuseId, for: indexPath) as! AlbumPrivateCell
    }

    var albumView: UILabel = {
        let label = UILabel()
        return label
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        contentView.addSubview(self.albumView)

        albumView.translatesAutoresizingMaskIntoConstraints = false

        albumView.topAnchor.constraint(equalTo: contentView.topAnchor).isActive = true
        albumView.leftAnchor.constraint(equalTo: contentView.leftAnchor).isActive = true
        albumView.rightAnchor.constraint(equalTo: contentView.rightAnchor).isActive = true
        albumView.bottomAnchor.constraint(equalTo: contentView.bottomAnchor).isActive = true
    }

    required init?(coder: NSCoder) {
        fatalError("init?(coder: NSCoder) has not been implemented")
    }
}

struct AlbumGridView: UIViewRepresentable {
    var data = [1,2,3,4,5,6,7,8,9]

    func makeUIView(context: Context) -> UICollectionView {
        let collectionView = UICollectionView(frame: .zero, collectionViewLayout: UICollectionViewFlowLayout())
        collectionView.backgroundColor = .blue
        collectionView.translatesAutoresizingMaskIntoConstraints = false
        collectionView.dataSource = context.coordinator
        collectionView.delegate = context.coordinator

        AlbumPrivateCell.registerWithCollectionView(collectionView: collectionView)
        return collectionView
    }

    func updateUIView(_ uiView: UICollectionView, context: Context) {
        //
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    class Coordinator: NSObject, UICollectionViewDataSource, UICollectionViewDelegateFlowLayout {
        private let parent: AlbumGridView

        init(_ albumGridView: AlbumGridView) {
            self.parent = albumGridView
        }

        // MARK: UICollectionViewDataSource

        func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
            self.parent.data.count
        }

        func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
            let albumCell = AlbumPrivateCell.getReusedCellFrom(collectionView: collectionView, cellForItemAt: indexPath)
            albumCell.backgroundColor = .red

            return albumCell
        }

        // MARK: UICollectionViewDelegateFlowLayout

        func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
            let width = collectionView.frame.width / 3
            return CGSize(width: width, height: width)
        }
    }
}

截屏

score 8 · Accepted Answer

我们开发了一个 swift 包，它提供了一个功能齐全的 CollectionView 以在 SwiftUI 中使用。

在这里找到它：https://github.com/apptekstudios/ASCollectionView

它被设计为易于使用，但也可以充分利用新的 UICollectionViewCompositionalLayout 进行更复杂的布局。它支持单元格的自动调整大小。

要实现网格视图，您可以按如下方式使用它：

import SwiftUI
import ASCollectionView

struct ExampleView: View {
    @State var dataExample = (0 ..< 21).map { $0 }

    var body: some View
    {
        ASCollectionView(data: dataExample, dataID: \.self) { item, _ in
            Color.blue
                .overlay(Text("\(item)"))
        }
        .layout {
            .grid(layoutMode: .adaptive(withMinItemSize: 100),
                  itemSpacing: 5,
                  lineSpacing: 5,
                  itemSize: .absolute(50))
        }
    }
}

有关更复杂布局的示例，请参阅演示项目。

score 6 · Accepted Answer

我自己一直在解决这个问题，并使用上面@Anjali 发布的源作为基础，以及@phillip（Avery Vine 的工作），我已经包装了一个功能性的 UICollectionView...ish ? 它将根据需要显示和更新网格。我还没有尝试过更可定制的视图或任何其他东西，但现在，我认为它会做。

我在下面评论了我的代码，希望它对某人有用！

首先，包装。

struct UIKitCollectionView: UIViewRepresentable {
    typealias UIViewType = UICollectionView

    //This is where the magic happens! This binding allows the UI to update.
    @Binding var snapshot: NSDiffableDataSourceSnapshot<DataSection, DataObject>

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    func makeUIView(context: UIViewRepresentableContext<UIKitCollectionView>) -> UICollectionView {

        //Create and configure your layout flow seperately
        let flowLayout = UICollectionViewFlowLayout()
        flowLayout.sectionInsets = UIEdgeInsets(top: 25, left: 0, bottom: 25, right: 0)


        //And create the UICollection View
        let collectionView = UICollectionView(frame: .zero, collectionViewLayout: flowLayout)

        //Create your cells seperately, and populate as needed.
        collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: "customCell")

        //And set your datasource - referenced from Avery
        let dataSource = UICollectionViewDiffableDataSource<DataSection, DataObject>(collectionView: collectionView) { (collectionView, indexPath, object) -> UICollectionViewCell? in
            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "customCell", for: indexPath)
            //Do cell customization here
            if object.id.uuidString.contains("D") {
                cell.backgroundColor = .red
            } else {
                cell.backgroundColor = .green
            }


            return cell
        }

        context.coordinator.dataSource = dataSource

        populate(load: [DataObject(), DataObject()], dataSource: dataSource)
        return collectionView
    }

    func populate(load: [DataObject], dataSource: UICollectionViewDiffableDataSource<DataSection, DataObject>) {
        //Load the 'empty' state here!
        //Or any default data. You also don't even have to call this function - I just thought it might be useful, and Avery uses it in their example.

        snapshot.appendItems(load)
        dataSource.apply(snapshot, animatingDifferences: true) {
            //Whatever other actions you need to do here.
        }
    }


    func updateUIView(_ uiView: UICollectionView, context: UIViewRepresentableContext<UIKitCollectionView>) {
        let dataSource = context.coordinator.dataSource
        //This is where updates happen - when snapshot is changed, this function is called automatically.

        dataSource?.apply(snapshot, animatingDifferences: true, completion: {
            //Any other things you need to do here.
        })

    }

    class Coordinator: NSObject {
        var parent: UIKitCollectionView
        var dataSource: UICollectionViewDiffableDataSource<DataSection, DataObject>?
        var snapshot = NSDiffableDataSourceSnapshot<DataSection, DataObject>()

        init(_ collectionView: UIKitCollectionView) {
            self.parent = collectionView
        }
    }
}

现在，DataProvider该类将允许我们访问该可绑定快照并在需要时更新 UI。此类对于正确更新集合视图至关重要。这些模型DataSection和与Avery VineDataObject提供的模型具有相同的结构- 因此，如果您需要这些模型，请看那里。

class DataProvider: ObservableObject { //This HAS to be an ObservableObject, or our UpdateUIView function won't fire!
    var data = [DataObject]()

    @Published var snapshot : NSDiffableDataSourceSnapshot<DataSection, DataObject> = {
        //Set all of your sections here, or at least your main section.
        var snap = NSDiffableDataSourceSnapshot<DataSection, DataObject>()
        snap.appendSections([.main, .second])
        return snap
        }() {
        didSet {
            self.data = self.snapshot.itemIdentifiers
            //I set the 'data' to be equal to the snapshot here, in the event I just want a list of the data. Not necessary.
        }
    }

    //Create any snapshot editing functions here! You can also simply call snapshot functions directly, append, delete, but I have this addItem function to prevent an exception crash.
    func addItems(items: [DataObject], to section: DataSection) {
        if snapshot.sectionIdentifiers.contains(section) {
            snapshot.appendItems(items, toSection: section)
        } else {
            snapshot.appendSections([section])
            snapshot.appendItems(items, toSection: section)
        }
    }
}

现在，CollectionView将展示我们的新系列。我用一些按钮制作了一个简单的 VStack，以便您可以看到它的运行情况。

struct CollectionView: View {
    @ObservedObject var dataProvider = DataProvider()

    var body: some View {
        VStack {
            UIKitCollectionView(snapshot: $dataProvider.snapshot)
            Button("Add a box") {
                self.dataProvider.addItems(items: [DataObject(), DataObject()], to: .main)
            }

            Button("Append a Box in Section Two") {
                self.dataProvider.addItems(items: [DataObject(), DataObject()], to: .second)
            }

            Button("Remove all Boxes in Section Two") {
                self.dataProvider.snapshot.deleteSections([.second])
            }
        }
    }
}

struct CollectionView_Previews: PreviewProvider {
    static var previews: some View {
        CollectionView()
    }
}

仅针对那些视觉参考（是的，这是在 Xcode 预览窗口中运行的）：

score 5 · Accepted Answer

更新：此答案与 iOS 13 有关。对于 iOS 14，我们有 LazyGrids + 更多内容，遵循此答案将无济于事。

为了在不使用 UIKit 的情况下制作 CollectionView，首先我们需要一个数组扩展。数组扩展将帮助我们分块我们想要制作 TableView 的数组。下面是扩展的代码，+ 3 个示例。要进一步了解此扩展程序的工作原理，请查看此站点，我从以下站点复制了扩展程序：https ://www.hackingwithswift.com/example-code/language/how-to-split-一个数组到块

    extension Array {
    func chunked(into size: Int) -> [[Element]] {
        return stride(from: 0, to: count, by: size).map {
            Array(self[$0 ..< Swift.min($0 + size, count)])
        }
    }
}

let exampleArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(exampleArray.chunked(into: 2)) // prints [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]

print(exampleArray.chunked(into: 3)) // prints [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

print(exampleArray.chunked(into: 5)) // prints [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12]]

现在让我们制作我们的 SwiftUI 视图：

struct TestView: View {
    
    let arrayOfInterest = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18].chunked(into: 4)
    // = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16], [17, 18]] 
    
    var body: some View {
        
        return VStack {
            
            ScrollView {
                
                VStack(spacing: 16) {
                    
                    ForEach(self.arrayOfInterest.indices, id:\.self) { idx in
                        
                        HStack {
                            
                            ForEach(self.arrayOfInterest[idx].indices, id:\.self) { index in
                                
                                HStack {
                                    
                                    Spacer()
                                    Text("\(self.arrayOfInterest[idx][index])")
                                        .font(.system(size: 50))
                                    .padding(4)
                                        .background(Color.blue)
                                        .cornerRadius(8)
                                    
                                    Spacer()
                                    
                                }
                                
                            }
                            
                        }
                        
                    }
                    
                }
                
            }
            
        }
        
    }
    
}


struct TestView_Preview : PreviewProvider {
    
    static var previews: some View {
            TestView()
        }
    
}

上面代码的预览图

解释：

首先，我们需要明确我们需要多少列，并将该数字放入我们的分块扩展中。在我的示例中，我们有一个从 1 到 18 的数字数组（arrayOfInterest），我们想在视图中显示它，我决定我希望我的视图有 4 列，所以我将它分成 4 列（所以 4 是数字我们的专栏）。

要制作一个 CollectionView，最明显的是我们的 CollectionView 是一个项目列表，所以它应该在一个列表中以使其易于滚动（不，不要那样做！改用 ScrollView。我见过奇怪的行为而这两个 foreachs 在列表中）。在 ScrollView 之后我们有 2 个 ForEach ，第一个使我们能够根据需要循环尽可能多的 Rows，而第二个帮助我们制作列。

我知道我没有完美地解释代码，但我相信它值得与您分享，这样可以让您更轻松地查看表格。这张图片是我正在制作的真实应用程序的早期示例，它看起来与 CollectionView 没什么区别，因此您可以确定这种方法效果很好。

问题：拥有一个数组并试图让 swift 为 foreach 制作这些索引有什么意义？
这很简单！如果您有一个在运行时定义其值/值数的数组，例如，您从 web api 获取数字并且该 api 告诉您数组中有多少数字，那么您需要使用一些方法像这样，让 swift 处理 foreachs 的索引。

更新：

更多信息，阅读这些是可选的。

LIST VS SCROLLVIEW：有些人可能不知道，列表的工作方式与滚动视图有点不同。当你创建一个滚动视图时，它总是计算整个滚动视图，然后显示给我们。但是 list 不会这样做，当使用列表时，swift 会自动计算仅显示当前视图所需的列表的少数组件，并且当您向下滚动到列表底部时，它只会替换正在执行的旧值滚动出屏幕底部的新值。所以一般来说， list 总是更轻，当你使用重视图时可以更快，因为它不会在开始时计算你的所有视图，并且只计算必要的东西，而 ScrollView 没有。

为什么你说我们应该使用滚动视图而不是列表？ 正如我之前所说，列表中有一些你可能不喜欢的交互。例如，在创建列表时，每一行都是可点击的，这很好，但不好的是只有整行是可点击的！这意味着您不能为行的左侧设置点击动作，而为右侧设置不同的点击动作！这只是 List() 的奇怪交互之一，这需要一些我没有的知识！或者是一个很大的 xcode-ios 问题，或者它可能很好并且符合预期！我认为这是一个苹果问题，我希望它最多能在下一个 WWDC 之前得到修复。（更新：当然，它通过引入所有的东西得到修复，比如用于 iOS14-SwiftUI 的 LazyGrids）

有什么办法可以克服这个问题？ 据我所知，唯一的方法是使用 UIKit。我用 SwiftUI 尝试了很多方法，虽然我发现你可以从 ActionSheet 和 ContextMenu 获得帮助，以便在你点击它们时在选项方面更好地制作列表，但我无法从中获得最佳预期功能一个 SwiftUI 列表。所以从我的观点来看，SwiftUI 开发者只能等待。

score 2 · Accepted Answer

在此处查看基于 ZStack 的示例

Grid(0...100) { _ in
    Rectangle()
        .foregroundColor(.blue)
}

score 2 · Accepted Answer

厌倦了寻找许多复杂的解决方案或 Github 库，我决定自己做一个简单而漂亮的数学解决方案。

认为您有一系列项目var items : [ITEM] = [...YOUR_ITEMS...]
你想显示一个Nx2的网格

当N是ROWS的数量并且2是 COLUMNS的数量时

要显示所有项目，您需要使用两个ForEach语句，一个用于列，一个用于行。

进入两者ForEach：（i）ROWS的当前索引和（j）COLUMNS 的当前索引

显示索引中的当前项 [( i * 2 ) + j ]
现在让我们进入代码：

注意：Xcode 11.3.1

var items : [ITEM] = [...YOUR_ITEMS...]
var body: some View {
VStack{
    // items.count/2 represent the number of rows
    ForEach(0..< items.count/2){ i in
        HStack(alignment: .center,spacing: 20){
            //2 columns 
            ForEach(0..<2){ j in
               //Show your custom view here
               // [(i*2) + j] represent the index of the current item 
                ProductThumbnailView(product: self.items[(i*2) + j])
            }
        }
        }.padding(.horizontal)
    Spacer()
   }
}

score 1 · Accepted Answer

尝试使用 VStack 和 HStack

var body: some View {
    GeometryReader { geometry in
        VStack {
            ForEach(1...3) {_ in
                HStack {
                    Color.orange.frame(width: 100, height: 100)
                    Color.orange.frame(width: 100, height: 100)
                    Color.orange.frame(width: 100, height: 100)
                }.frame(width: geometry.size.width, height: 100)
            }
        }
    }
}

如果你想滚动，你可以包裹在一个 ScrollView

score 1 · Accepted Answer

我认为您可以像这样使用滚动视图

struct MovieItemView : View {
    var body: some View {
        VStack {
            Image("sky")
                .resizable()
                .frame(width: 150, height: 200)
            VStack {
                Text("Movie Title")
                    .font(.headline)
                    .fontWeight(.bold)
                Text("Category")
                    .font(.subheadline)
            }
        }
    }
}

struct MoviesView : View {
    var body: some View {
        VStack(alignment: .leading, spacing: 10){
            Text("Now Playing")
                .font(.title)
                .padding(.leading)
            ScrollView {
                HStack(spacing: 10) {
                    MovieItemView()
                    MovieItemView()
                    MovieItemView()
                    MovieItemView()
                    MovieItemView()
                    MovieItemView()
                }
            }
            .padding(.leading, 20)
        }
    }
}

score 1 · Accepted Answer

我编写了一个名为 GridStack 的小组件，它制作了一个可以调整到可用宽度的网格。即使当你旋转 iPad 时，它也会动态变化。

https://github.com/pietropizzi/GridStack

该实现的要点与其他人在此处回答的内容相似（所以HStack在 a 中VStack），不同之处在于它根据可用宽度和您传递的配置来计算宽度。

随着minCellWidth您定义您希望网格中的项目应该具有的最小宽度
spacing您可以定义网格中项目之间的空间。

例如

GridStack(
    minCellWidth: 320,
    spacing: 15,
    numItems: yourItems.count
) { index, cellWidth in
    YourItemView(item: yourItems[index]).frame(width: cellWidth)
}

score 1 · Accepted Answer

因为我没有使用 Catalina Beta，所以我在这里写了我的代码，你可以在 Xcode 11 (Mojave) 上运行作为游乐场，以利用运行时编译和预览

基本上，当您寻找网格方法时，您应该记住 SwiftUI 子视图从父视图获取理想的大小参数，以便它们可以根据自己的内容自动适应，这种行为可以被覆盖（不要与 swift Override 指令混淆）通过 .frame(...) 方法将视图强制为特定大小。

在我看来，这使得 View 行为稳定并且 Apple SwiftUI 框架已经过正确测试。

import PlaygroundSupport
import SwiftUI

struct ContentView: View {

    var body: some View {

        VStack {
            ForEach(0..<5) { _ in
                HStack(spacing: 0) {
                    ForEach(0..<5) { _ in
                        Button(action: {}) {
                            Text("Ok")
                        }
                        .frame(minWidth: nil, idealWidth: nil, maxWidth: .infinity, minHeight: nil, idealHeight: nil, maxHeight: .infinity, alignment: .center)
                        .border(Color.red)
                    }
                }
            }
        }
    }
}

let contentView = ContentView()
PlaygroundPage.current.liveView = UIHostingController(rootView: contentView)

score 1 · Accepted Answer

尽管下一个 WWDC 即将到来，但我们仍然缺少SwiftUI. 我试图提供一个不错的示例，说明如何使用和创建自己的SwiftUI 集合视图。我选择创建自己的集合视图，而不是使用开源库，因为我觉得它们缺少一些关键功能，或者因为太多东西而臃肿。在我的示例中，我使用和创建了集合视图。它同时支持和功能。UIViewControllerRepresentableCombineUICollectionViewDiffableDataSourceUICollectionViewCompositionalLayoutpullToRefreshpagination

完整的实现可以在：https ://github.com/shabib87/SwiftUICollectionView 中找到。

score 0 · Accepted Answer

根据 Will 的回答，我将其全部封装在 SwiftUI ScrollView 中。所以你可以实现水平（在这种情况下）或垂直滚动。

它还使用 GeometryReader，因此可以使用屏幕尺寸进行计算。

GeometryReader{ geometry in
 .....
 Rectangle()
    .fill(Color.blue)
    .frame(width: geometry.size.width/6, height: geometry.size.width/6, alignment: .center)
 }

这是一个工作示例：

import SwiftUI

struct MaterialView: View {

  var body: some View {

    GeometryReader{ geometry in

      ScrollView(Axis.Set.horizontal, showsIndicators: true) {
        ForEach(0..<2) { _ in
          HStack {
            ForEach(0..<30) { index in
              ZStack{
                Rectangle()
                  .fill(Color.blue)
                  .frame(width: geometry.size.width/6, height: geometry.size.width/6, alignment: .center)

                Text("\(index)")
              }
            }
          }.background(Color.red)
        }
      }.background(Color.black)
    }

  }
}

struct MaterialView_Previews: PreviewProvider {
  static var previews: some View {
    MaterialView()
  }
}

ios - UICollectionView 和 SwiftUI？

16 回答 16

代码

截屏

Related

Reference