@Environment(\.managedObjectContext) private var viewContext
    
@FetchRequest(
    sortDescriptors: [NSSortDescriptor(keyPath: \FootmarkEntity.startTime, ascending: false)],
    animation: .default)
private var footmarks: FetchedResults<FootmarkEntity>

private func addItem() {
    withAnimation {
        let newItem = FootmarkEntity(context: viewContext)
        // 实体赋值
        let randomNumber:Int = Int(arc4random() % 100) + 1
        newItem.id  = String(randomNumber);
        newItem.endTime = Date()
        newItem.startTime = Date()
        // 保存
        do {
            try viewContext.save()
        } catch {
            let nsError = error as NSError
            fatalError("添加失败 \(nsError), \(nsError.userInfo)")
        }
    }
}

extension UINavigationController: UIGestureRecognizerDelegate {
    override open func viewDidLoad() {
        super.viewDidLoad()
        interactivePopGestureRecognizer?.delegate = self
    }

    public func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
        return viewControllers.count > 1
    }
}

struct ImageTabView: View {
    @EnvironmentObject var imageTabViewEnviroment:ImageTabViewEnvironment

    var body: some View {
        VStack{
            TabView(selection:$imageTabViewEnviroment.index) {
                ForEach(0..<imageTabViewEnviroment.imageArray.count,id: \.self){ index in
                    ImageTabViewItemView(imageUrl: imageTabViewEnviroment.imageArray[index])
                }
            }
            .tabViewStyle(PageTabViewStyle())
            .indexViewStyle(PageIndexViewStyle(backgroundDisplayMode: .always))
        }
        .edgesIgnoringSafeArea(.all)
    }
}

private struct ImageTabViewItemView:View {
    @State var scale: CGFloat = 1
    @State private var dragOffset = CGSize.zero
    @State var imageUrl: String
    var body: some View{
        VStack{
            ZoomableScrollView {
                MyKingfisherView(urlStr: imageUrl)
            }
        }
        .frame(height:UIScreen.main.bounds.height)
        .clipped()
    }
}

struct ZoomableScrollView<Content: View>: UIViewRepresentable {
  private var content: Content

  init(@ViewBuilder content: () -> Content) {
    self.content = content()
  }

  func makeUIView(context: Context) -> UIScrollView {
    // set up the UIScrollView
    let scrollView = UIScrollView()
    scrollView.delegate = context.coordinator  // for viewForZooming(in:)
    scrollView.maximumZoomScale = 20
    scrollView.minimumZoomScale = 1
    scrollView.bouncesZoom = true

    // create a UIHostingController to hold our SwiftUI content
    let hostedView = context.coordinator.hostingController.view!
    hostedView.translatesAutoresizingMaskIntoConstraints = true
    hostedView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
    hostedView.frame = scrollView.bounds
    scrollView.addSubview(hostedView)

    return scrollView
  }

  func makeCoordinator() -> Coordinator {
    return Coordinator(hostingController: UIHostingController(rootView: self.content))
  }

  func updateUIView(_ uiView: UIScrollView, context: Context) {
    // update the hosting controller's SwiftUI content
    context.coordinator.hostingController.rootView = self.content
    assert(context.coordinator.hostingController.view.superview == uiView)
  }

  // MARK: - Coordinator

  class Coordinator: NSObject, UIScrollViewDelegate {
    var hostingController: UIHostingController<Content>

    init(hostingController: UIHostingController<Content>) {
      self.hostingController = hostingController
    }

    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
      return hostingController.view
    }
  }
}

struct PageView<SelectionValue, Content>: View where SelectionValue: Hashable, Content: View {
    @Binding private var selection: SelectionValue
    private let indexDisplayMode: PageTabViewStyle.IndexDisplayMode
    private let indexBackgroundDisplayMode: PageIndexViewStyle.BackgroundDisplayMode
    private let content: () -> Content

    init(
        selection: Binding<SelectionValue>,
        indexDisplayMode: PageTabViewStyle.IndexDisplayMode = .automatic,
        indexBackgroundDisplayMode: PageIndexViewStyle.BackgroundDisplayMode = .automatic,
        @ViewBuilder content: @escaping () -> Content
    ) {
        self._selection = selection
        self.indexDisplayMode = indexDisplayMode
        self.indexBackgroundDisplayMode = indexBackgroundDisplayMode
        self.content = content
        print(selection)
        print(indexDisplayMode)
        print(indexBackgroundDisplayMode)
    }

    var body: some View {
        TabView(selection: $selection) {
            content()
        }
        .tabViewStyle(PageTabViewStyle(indexDisplayMode: indexDisplayMode))
        .indexViewStyle(PageIndexViewStyle(backgroundDisplayMode: indexBackgroundDisplayMode))
    }
}

extension PageView where SelectionValue == Int {
    init(
        indexDisplayMode: PageTabViewStyle.IndexDisplayMode = .automatic,
        indexBackgroundDisplayMode: PageIndexViewStyle.BackgroundDisplayMode = .automatic,
        @ViewBuilder content: @escaping () -> Content
    ) {
        self._selection = .constant(0)
        self.indexDisplayMode = indexDisplayMode
        self.indexBackgroundDisplayMode = indexBackgroundDisplayMode
        self.content = content
    }
}

struct TestPageView1:View {
    var body: some View{
        Text("1")
            .onLoad {
                print("初次加载1")
            }
    }
}
struct TestPageView2:View {
    var body: some View{
        Text("2")
            .onLoad {
                print("初次加载2")
            }
    }
}
struct TestPageView3:View {
    var body: some View{
        Text("3")
            .onLoad {
                print("初次加载3")
            }
    }
}

struct Test_PageView:View {
    @State var selection = 1
    var body: some View {
        VStack {
            Text("Selection: \(selection)")
            PageView(selection: $selection, indexBackgroundDisplayMode: .never) {
                TestPageView1()
                TestPageView2()
                TestPageView3()
            }
        }
    }
}

struct ViewDidLoadModifier: ViewModifier {

    @State private var didLoad = false
    private let action: (() -> Void)?

    init(perform action: (() -> Void)? = nil) {
        self.action = action
    }

    func body(content: Content) -> some View {
        content.onAppear {
            if didLoad == false {
                didLoad = true
                action?()
            }
        }
    }

}

extension View {

    func onLoad(perform action: (() -> Void)? = nil) -> some View {
        modifier(ViewDidLoadModifier(perform: action))
    }

}

if keyboard.currentHeight != 0 {
    Color.gray
        .edgesIgnoringSafeArea(.all)
        .opacity(0.4)
        .onTapGesture {
            withAnimation(.spring()){
                UIApplication.shared.windows.forEach { (window) in
                    if window.isKeyWindow {
                        window.endEditing(true)
                    }
                }
            }
        }
}

import UIKit
import Foundation
import SwiftUI
import Combine
class KeyboardResponder: ObservableObject {
    private var _center: NotificationCenter
    @Published var currentHeight: CGFloat = 0

    init(center: NotificationCenter = .default) {
        _center = center
        _center.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
        _center.addObserver(self, selector: #selector(keyBoardWillHide(notification:)), name: UIResponder.keyboardWillHideNotification, object: nil)
    }

    deinit {
        _center.removeObserver(self)
    }

    @objc func keyBoardWillShow(notification: Notification) {
        if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
            currentHeight = keyboardSize.height
        }
    }

    @objc func keyBoardWillHide(notification: Notification) {
        currentHeight = 0
    }
}

class KeyboardHeightHelper: ObservableObject {
    @Published var keyboardHeight: CGFloat = 0

    init() {
        self.listenForKeyboardNotifications()
    }
    private func listenForKeyboardNotifications() {
        NotificationCenter.default.addObserver(forName: UIResponder.keyboardDidShowNotification,
                                               object: nil,
                                               queue: .main) { (notification) in
                                                guard let userInfo = notification.userInfo,
                                                    let keyboardRect = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
                                                self.keyboardHeight = keyboardRect.height
        }

        NotificationCenter.default.addObserver(forName: UIResponder.keyboardDidHideNotification,
                                               object: nil,
                                               queue: .main) { (notification) in
                                                self.keyboardHeight = 0
        }
    }
}

sudo npm install n -g

sudo n stable

sudo n latest

sudo n 版本号//例如：sudo n 9.1.7