ฉันมีเจ็ดภายในหลักของฉันTextField ContentViewเมื่อผู้ใช้เปิดแป้นพิมพ์บางส่วนTextFieldจะซ่อนอยู่ใต้กรอบแป้นพิมพ์ ดังนั้นฉันต้องการย้ายทั้งหมดTextFieldตามลำดับเมื่อแป้นพิมพ์ปรากฏขึ้น

ฉันได้ใช้รหัสด้านล่างเพื่อเพิ่มTextFieldบนหน้าจอ

struct ContentView : View {
    @State var textfieldText: String = ""

    var body: some View {
            VStack {
                TextField($textfieldText, placeholder: Text("TextField1"))
                TextField($textfieldText, placeholder: Text("TextField2"))
                TextField($textfieldText, placeholder: Text("TextField3"))
                TextField($textfieldText, placeholder: Text("TextField4"))
                TextField($textfieldText, placeholder: Text("TextField5"))
                TextField($textfieldText, placeholder: Text("TextField6"))
                TextField($textfieldText, placeholder: Text("TextField6"))
                TextField($textfieldText, placeholder: Text("TextField7"))
            }
    }
}

เอาท์พุต:

รหัสอัปเดตสำหรับ Xcode เบต้า 7

คุณไม่จำเป็นต้องมีช่องว่างภายใน ScrollViews หรือรายการเพื่อให้บรรลุเป้าหมายนี้ แม้ว่าโซลูชันนี้จะเล่นได้ดีกับพวกเขาด้วย ฉันรวมสองตัวอย่างไว้ที่นี่

อันแรกจะย้ายtextField ทั้งหมดขึ้นหากแป้นพิมพ์ปรากฏขึ้นสำหรับแป้นพิมพ์ใด ๆ แต่ถ้าจำเป็นเท่านั้น หากแป้นพิมพ์ไม่ซ่อนช่องข้อความก็จะไม่ขยับ

ในตัวอย่างที่สองมุมมองจะเคลื่อนไหวเพียงพอเพียงเพื่อหลีกเลี่ยงการซ่อนช่องข้อความที่ใช้งานอยู่

ทั้งสองตัวอย่างใช้รหัสทั่วไปเดียวกันที่พบในตอนท้าย: GeometryGetterและKeyboardGuardian

ตัวอย่างแรก (แสดงฟิลด์ข้อความทั้งหมด)

struct ContentView: View {
    @ObservedObject private var kGuardian = KeyboardGuardian(textFieldCount: 1)
    @State private var name = Array<String>.init(repeating: "", count: 3)

    var body: some View {

        VStack {
            Group {
                Text("Some filler text").font(.largeTitle)
                Text("Some filler text").font(.largeTitle)
            }

            TextField("enter text #1", text: $name[0])
                .textFieldStyle(RoundedBorderTextFieldStyle())

            TextField("enter text #2", text: $name[1])
                .textFieldStyle(RoundedBorderTextFieldStyle())

            TextField("enter text #3", text: $name[2])
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .background(GeometryGetter(rect: $kGuardian.rects[0]))

        }.offset(y: kGuardian.slide).animation(.easeInOut(duration: 1.0))
    }

}

ตัวอย่างที่สอง (แสดงเฉพาะฟิลด์ที่ใช้งานอยู่)

struct ContentView: View {
    @ObservedObject private var kGuardian = KeyboardGuardian(textFieldCount: 3)
    @State private var name = Array<String>.init(repeating: "", count: 3)

    var body: some View {

        VStack {
            Group {
                Text("Some filler text").font(.largeTitle)
                Text("Some filler text").font(.largeTitle)
            }

            TextField("text #1", text: $name[0], onEditingChanged: { if $0 { self.kGuardian.showField = 0 } })
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .background(GeometryGetter(rect: $kGuardian.rects[0]))

            TextField("text #2", text: $name[1], onEditingChanged: { if $0 { self.kGuardian.showField = 1 } })
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .background(GeometryGetter(rect: $kGuardian.rects[1]))

            TextField("text #3", text: $name[2], onEditingChanged: { if $0 { self.kGuardian.showField = 2 } })
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .background(GeometryGetter(rect: $kGuardian.rects[2]))

            }.offset(y: kGuardian.slide).animation(.easeInOut(duration: 1.0))
    }.onAppear { self.kGuardian.addObserver() } 
.onDisappear { self.kGuardian.removeObserver() }

}

เรขาคณิต

นี่คือมุมมองที่ดูดซับขนาดและตำแหน่งของมุมมองระดับบนสุด เพื่อให้บรรลุเป้าหมายนั้นเรียกว่าภายในตัวปรับแต่ง. background นี่เป็นตัวปรับแต่งที่ทรงพลังมากไม่ใช่แค่วิธีตกแต่งพื้นหลังของมุมมอง เมื่อส่งมุมมองไปยัง. background (MyView ()) MyView จะได้รับมุมมองที่แก้ไขเป็นพาเรนต์ การใช้ GeometryReader เป็นสิ่งที่ทำให้มุมมองทราบรูปทรงเรขาคณิตของพาเรนต์

ตัวอย่างเช่นText("hello").background(GeometryGetter(rect: $bounds))จะเติมเต็มขอบเขตของตัวแปรด้วยขนาดและตำแหน่งของมุมมองข้อความและใช้พื้นที่พิกัดส่วนกลาง

struct GeometryGetter: View {
    @Binding var rect: CGRect

    var body: some View {
        GeometryReader { geometry in
            Group { () -> AnyView in
                DispatchQueue.main.async {
                    self.rect = geometry.frame(in: .global)
                }

                return AnyView(Color.clear)
            }
        }
    }
}

อัปเดตฉันได้เพิ่ม DispatchQueue.main.async เพื่อหลีกเลี่ยงความเป็นไปได้ในการแก้ไขสถานะของมุมมองในขณะที่กำลังแสดงผล ***

KeyboardGuardian

วัตถุประสงค์ของ KeyboardGuardian คือการติดตามการแสดงแป้นพิมพ์ / ซ่อนเหตุการณ์และคำนวณว่าจะต้องเปลี่ยนพื้นที่มุมมองเท่าใด

อัปเดต: ฉันแก้ไข KeyboardGuardian เพื่อรีเฟรชสไลด์เมื่อผู้ใช้แท็บจากฟิลด์หนึ่งไปอีกฟิลด์หนึ่ง

import SwiftUI
import Combine

final class KeyboardGuardian: ObservableObject {
    public var rects: Array<CGRect>
    public var keyboardRect: CGRect = CGRect()

    // keyboardWillShow notification may be posted repeatedly,
    // this flag makes sure we only act once per keyboard appearance
    public var keyboardIsHidden = true

    @Published var slide: CGFloat = 0

    var showField: Int = 0 {
        didSet {
            updateSlide()
        }
    }

    init(textFieldCount: Int) {
        self.rects = Array<CGRect>(repeating: CGRect(), count: textFieldCount)

    }

    func addObserver() {
NotificationCenter.default.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(keyBoardDidHide(notification:)), name: UIResponder.keyboardDidHideNotification, object: nil)
}

func removeObserver() {
 NotificationCenter.default.removeObserver(self)
}

    deinit {
        NotificationCenter.default.removeObserver(self)
    }



    @objc func keyBoardWillShow(notification: Notification) {
        if keyboardIsHidden {
            keyboardIsHidden = false
            if let rect = notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect {
                keyboardRect = rect
                updateSlide()
            }
        }
    }

    @objc func keyBoardDidHide(notification: Notification) {
        keyboardIsHidden = true
        updateSlide()
    }

    func updateSlide() {
        if keyboardIsHidden {
            slide = 0
        } else {
            let tfRect = self.rects[self.showField]
            let diff = keyboardRect.minY - tfRect.maxY

            if diff > 0 {
                slide += diff
            } else {
                slide += min(diff, 0)
            }

        }
    }
}

เพื่อสร้างโซลูชันของ @rraphael ฉันได้แปลงให้ใช้งานได้โดยการสนับสนุน xcode11 swiftUI ในปัจจุบัน

import SwiftUI

final class KeyboardResponder: ObservableObject {
    private var notificationCenter: NotificationCenter
    @Published private(set) var currentHeight: CGFloat = 0

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

    deinit {
        notificationCenter.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
    }
}

การใช้งาน:

struct ContentView: View {
    @ObservedObject private var keyboard = KeyboardResponder()
    @State private var textFieldInput: String = ""

    var body: some View {
        VStack {
            HStack {
                TextField("uMessage", text: $textFieldInput)
            }
        }.padding()
        .padding(.bottom, keyboard.currentHeight)
        .edgesIgnoringSafeArea(.bottom)
        .animation(.easeOut(duration: 0.16))
    }
}

การเผยแพร่currentHeightจะทริกเกอร์การเรนเดอร์ UI อีกครั้งและเลื่อน TextField ของคุณขึ้นเมื่อแป้นพิมพ์แสดงขึ้นและกลับลงเมื่อปิด อย่างไรก็ตามฉันไม่ได้ใช้ ScrollView

ฉันลองใช้วิธีแก้ปัญหาที่นำเสนอมากมายและแม้ว่าจะใช้งานได้ในกรณีส่วนใหญ่ แต่ฉันก็มีปัญหาบางอย่าง - ส่วนใหญ่เป็นพื้นที่ปลอดภัย (ฉันมีแบบฟอร์มอยู่ในแท็บของ TabView)

ฉันลงเอยด้วยการรวมโซลูชันที่แตกต่างกันเล็กน้อยและใช้ GeometryReader เพื่อให้ได้มุมมองด้านล่างที่ปลอดภัยของมุมมองที่เฉพาะเจาะจงและใช้ในการคำนวณของช่องว่างภายใน:

import SwiftUI
import Combine

struct AdaptsToKeyboard: ViewModifier {
    @State var currentHeight: CGFloat = 0

    func body(content: Content) -> some View {
        GeometryReader { geometry in
            content
                .padding(.bottom, self.currentHeight)
                .animation(.easeOut(duration: 0.16))
                .onAppear(perform: {
                    NotificationCenter.Publisher(center: NotificationCenter.default, name: UIResponder.keyboardWillShowNotification)
                        .merge(with: NotificationCenter.Publisher(center: NotificationCenter.default, name: UIResponder.keyboardWillChangeFrameNotification))
                        .compactMap { notification in
                            notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect
                    }
                    .map { rect in
                        rect.height - geometry.safeAreaInsets.bottom
                    }
                    .subscribe(Subscribers.Assign(object: self, keyPath: \.currentHeight))

                    NotificationCenter.Publisher(center: NotificationCenter.default, name: UIResponder.keyboardWillHideNotification)
                        .compactMap { notification in
                            CGFloat.zero
                    }
                    .subscribe(Subscribers.Assign(object: self, keyPath: \.currentHeight))
                })
        }
    }
}

การใช้งาน:

struct MyView: View {
    var body: some View {
        Form {...}
        .modifier(AdaptsToKeyboard())
    }
}

ฉันสร้างมุมมองที่สามารถห่อมุมมองอื่น ๆ เพื่อย่อขนาดเมื่อแป้นพิมพ์ปรากฏขึ้น

มันค่อนข้างง่าย เราสร้างผู้เผยแพร่สำหรับแป้นพิมพ์แสดง / onReceiveซ่อนเหตุการณ์และแล้วการสมัครสมาชิกกับพวกเขาโดยใช้ เราใช้ผลลัพธ์ของสิ่งนั้นเพื่อสร้างสี่เหลี่ยมผืนผ้าขนาดแป้นพิมพ์ด้านหลังแป้นพิมพ์

struct KeyboardHost<Content: View>: View {
    let view: Content

    @State private var keyboardHeight: CGFloat = 0

    private let showPublisher = NotificationCenter.Publisher.init(
        center: .default,
        name: UIResponder.keyboardWillShowNotification
    ).map { (notification) -> CGFloat in
        if let rect = notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect {
            return rect.size.height
        } else {
            return 0
        }
    }

    private let hidePublisher = NotificationCenter.Publisher.init(
        center: .default,
        name: UIResponder.keyboardWillHideNotification
    ).map {_ -> CGFloat in 0}

    // Like HStack or VStack, the only parameter is the view that this view should layout.
    // (It takes one view rather than the multiple views that Stacks can take)
    init(@ViewBuilder content: () -> Content) {
        view = content()
    }

    var body: some View {
        VStack {
            view
            Rectangle()
                .frame(height: keyboardHeight)
                .animation(.default)
                .foregroundColor(.clear)
        }.onReceive(showPublisher.merge(with: hidePublisher)) { (height) in
            self.keyboardHeight = height
        }
    }
}

จากนั้นคุณสามารถใช้มุมมองดังนี้:

var body: some View {
    KeyboardHost {
        viewIncludingKeyboard()
    }
}

หากต้องการย้ายเนื้อหาของมุมมองขึ้นแทนที่จะviewย่อขนาดสามารถเพิ่มช่องว่างภายในหรือออฟเซ็ตได้แทนที่จะใส่ลงใน VStack ด้วยสี่เหลี่ยมผืนผ้า

ฉันได้สร้างตัวปรับแต่งมุมมองที่ใช้งานง่ายจริงๆ

เพิ่มไฟล์ Swift ด้วยโค้ดด้านล่างและเพิ่มตัวปรับแต่งนี้ในมุมมองของคุณ:

.keyboardResponsive()

import SwiftUI

struct KeyboardResponsiveModifier: ViewModifier {
  @State private var offset: CGFloat = 0

  func body(content: Content) -> some View {
    content
      .padding(.bottom, offset)
      .onAppear {
        NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillShowNotification, object: nil, queue: .main) { notif in
          let value = notif.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect
          let height = value.height
          let bottomInset = UIApplication.shared.windows.first?.safeAreaInsets.bottom
          self.offset = height - (bottomInset ?? 0)
        }

        NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, object: nil, queue: .main) { notif in
          self.offset = 0
        }
    }
  }
}

extension View {
  func keyboardResponsive() -> ModifiedContent<Self, KeyboardResponsiveModifier> {
    return modifier(KeyboardResponsiveModifier())
  }
}

หรือคุณสามารถใช้IQKeyBoardManagerSwift

และสามารถเลือกที่จะเพิ่มสิ่งนี้ไปยังผู้ร่วมประชุมแอปของคุณเพื่อซ่อนแถบเครื่องมือและเปิดใช้งานการซ่อนแป้นพิมพ์เมื่อคลิกที่มุมมองอื่น ๆ จากนั้นแป้นพิมพ์

        IQKeyboardManager.shared.enableAutoToolbar = false
        IQKeyboardManager.shared.shouldShowToolbarPlaceholder = false
        IQKeyboardManager.shared.shouldResignOnTouchOutside = true
        IQKeyboardManager.shared.previousNextDisplayMode = .alwaysHide

คุณต้องเพิ่มScrollViewและกำหนดขนาดของแป้นพิมพ์ด้านล่างเพื่อให้เนื้อหาสามารถเลื่อนได้เมื่อแป้นพิมพ์ปรากฏขึ้น

ในการรับขนาดแป้นพิมพ์คุณจะต้องใช้NotificationCenterเพื่อลงทะเบียนเหตุการณ์คีย์บอร์ด คุณสามารถใช้คลาสที่กำหนดเองเพื่อดำเนินการดังต่อไปนี้:

import SwiftUI
import Combine

final class KeyboardResponder: BindableObject {
    let didChange = PassthroughSubject<CGFloat, Never>()

    private var _center: NotificationCenter
    private(set) var currentHeight: CGFloat = 0 {
        didSet {
            didChange.send(currentHeight)
        }
    }

    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) {
        print("keyboard will show")
        if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
            currentHeight = keyboardSize.height
        }
    }

    @objc func keyBoardWillHide(notification: Notification) {
        print("keyboard will hide")
        currentHeight = 0
    }
}

ความBindableObjectสอดคล้องจะช่วยให้คุณสามารถใช้คลาสนี้เป็นStateและทริกเกอร์การอัปเดตมุมมอง หากจำเป็นให้ดูบทช่วยสอนสำหรับBindableObject: บทช่วยสอน SwiftUI

เมื่อคุณได้รับคุณต้องกำหนดค่าScrollViewเพื่อลดขนาดเมื่อแป้นพิมพ์ปรากฏขึ้น เพื่อความสะดวกฉันห่อสิ่งนี้ScrollViewไว้ในส่วนประกอบบางอย่าง:

struct KeyboardScrollView<Content: View>: View {
    @State var keyboard = KeyboardResponder()
    private var content: Content

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

    var body: some View {
        ScrollView {
            VStack {
                content
            }
        }
        .padding(.bottom, keyboard.currentHeight)
    }
}

ScrollViewสิ่งที่คุณต้องทำตอนนี้คือการฝังเนื้อหาของคุณภายในที่กำหนดเอง

struct ContentView : View {
    @State var textfieldText: String = ""

    var body: some View {
        KeyboardScrollView {
            ForEach(0...10) { index in
                TextField(self.$textfieldText, placeholder: Text("TextField\(index)")) {
                    // Hide keyboard when uses tap return button on keyboard.
                    self.endEditing(true)
                }
            }
        }
    }

    private func endEditing(_ force: Bool) {
        UIApplication.shared.keyWindow?.endEditing(true)
    }
}

แก้ไข: พฤติกรรมการเลื่อนนั้นแปลกมากเมื่อซ่อนแป้นพิมพ์ บางทีการใช้ภาพเคลื่อนไหวเพื่ออัปเดตช่องว่างภายในอาจช่วยแก้ปัญหานี้ได้หรือคุณควรพิจารณาใช้อย่างอื่นนอกเหนือจากpaddingการปรับขนาดมุมมองแบบเลื่อน

Xcode 12 - รหัสบรรทัดเดียว

เพิ่มตัวปรับแต่งนี้ในไฟล์ TextField

.ignoresSafeArea(.keyboard, edges: .bottom)

Apple ได้เพิ่มแป้นพิมพ์เป็นภูมิภาคสำหรับพื้นที่ปลอดภัยเพื่อให้คุณสามารถใช้แป้นพิมพ์เพื่อเคลื่อนย้ายส่วนใดก็ได้Viewด้วยแป้นพิมพ์เหมือนกับภูมิภาคอื่น ๆ

ฉันตรวจสอบและปรับโครงสร้างโซลูชันที่มีอยู่เป็นแพ็คเกจ SPM ที่มีประโยชน์ซึ่งมี.keyboardAware()ตัวปรับแต่ง:

KeyboardAwareSwiftUI

ตัวอย่าง:

struct KeyboardAwareView: View {
    @State var text = "example"

    var body: some View {
        NavigationView {
            ScrollView {
                VStack(alignment: .leading) {
                    ForEach(0 ..< 20) { i in
                        Text("Text \(i):")
                        TextField("Text", text: self.$text)
                            .textFieldStyle(RoundedBorderTextFieldStyle())
                            .padding(.bottom, 10)
                    }
                }
                .padding()
            }
            .keyboardAware()  // <--- the view modifier
            .navigationBarTitle("Keyboard Example")
        }

    }
}

ที่มา:

import UIKit
import SwiftUI

public class KeyboardInfo: ObservableObject {

    public static var shared = KeyboardInfo()

    @Published public var height: CGFloat = 0

    private init() {
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardChanged), name: UIApplication.keyboardWillShowNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardChanged), name: UIResponder.keyboardWillHideNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardChanged), name: UIResponder.keyboardWillChangeFrameNotification, object: nil)
    }

    @objc func keyboardChanged(notification: Notification) {
        if notification.name == UIApplication.keyboardWillHideNotification {
            self.height = 0
        } else {
            self.height = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect)?.height ?? 0
        }
    }

}

struct KeyboardAware: ViewModifier {
    @ObservedObject private var keyboard = KeyboardInfo.shared

    func body(content: Content) -> some View {
        content
            .padding(.bottom, self.keyboard.height)
            .edgesIgnoringSafeArea(self.keyboard.height > 0 ? .bottom : [])
            .animation(.easeOut)
    }
}

extension View {
    public func keyboardAware() -> some View {
        ModifiedContent(content: self, modifier: KeyboardAware())
    }
}

ฉันใช้คำตอบของเบนจามินคินเดิลเป็นจุดเริ่มต้น แต่ฉันมีปัญหาบางอย่างที่ฉันต้องการแก้ไข

1. คำตอบส่วนใหญ่ไม่ได้เกี่ยวข้องกับแป้นพิมพ์ที่เปลี่ยนกรอบดังนั้นจะแตกหากผู้ใช้หมุนอุปกรณ์ด้วยแป้นพิมพ์บนหน้าจอ การเพิ่มkeyboardWillChangeFrameNotificationในรายการที่อยู่การแจ้งเตือนที่ดำเนินการนี้
2. ฉันไม่ต้องการให้ผู้เผยแพร่โฆษณาหลายรายมีการปิดแผนที่ที่เหมือนกัน แต่แตกต่างกันดังนั้นฉันจึงผูกมัดการแจ้งเตือนแป้นพิมพ์ทั้งสามไว้ในผู้เผยแพร่รายเดียว เป็นห่วงโซ่ยาว แต่แต่ละขั้นตอนค่อนข้างตรงไปตรงมา
3. ฉันจัดเตรียมinitฟังก์ชันที่ยอมรับ a @ViewBuilderเพื่อให้คุณสามารถใช้KeyboardHostมุมมองเหมือนกับมุมมองอื่น ๆ และส่งผ่านเนื้อหาของคุณในการปิดท้ายแทนที่จะส่งผ่านมุมมองเนื้อหาเป็นพารามิเตอร์ไปยังinitและก็ผ่านเนื้อหาของคุณในการปิดท้ายเมื่อเทียบกับการส่งผ่านมุมมองที่เนื้อหาเป็นพารามิเตอร์ไป
4. ตามที่ Tae และ fdelafuente แนะนำในความคิดเห็นฉันได้เปลี่ยนไฟล์ Rectangleสำหรับปรับช่องว่างด้านล่าง
5. แทนที่จะใช้สตริง "UIKeyboardFrameEndUserInfoKey" แบบฮาร์ดโค้ดฉันต้องการใช้สตริงที่ให้มาในUIWindowรูปแบบUIWindow.keyboardFrameEndUserInfoKey.

ฉันดึงสิ่งเหล่านี้เข้าด้วยกัน:

struct KeyboardHost<Content>: View  where Content: View {
    var content: Content

    /// The current height of the keyboard rect.
    @State private var keyboardHeight = CGFloat(0)

    /// A publisher that combines all of the relevant keyboard changing notifications and maps them into a `CGFloat` representing the new height of the
    /// keyboard rect.
    private let keyboardChangePublisher = NotificationCenter.Publisher(center: .default,
                                                                       name: UIResponder.keyboardWillShowNotification)
        .merge(with: NotificationCenter.Publisher(center: .default,
                                                  name: UIResponder.keyboardWillChangeFrameNotification))
        .merge(with: NotificationCenter.Publisher(center: .default,
                                                  name: UIResponder.keyboardWillHideNotification)
            // But we don't want to pass the keyboard rect from keyboardWillHide, so strip the userInfo out before
            // passing the notification on.
            .map { Notification(name: $0.name, object: $0.object, userInfo: nil) })
        // Now map the merged notification stream into a height value.
        .map { ($0.userInfo?[UIWindow.keyboardFrameEndUserInfoKey] as? CGRect ?? .zero).size.height }
        // If you want to debug the notifications, swap this in for the final map call above.
//        .map { (note) -> CGFloat in
//            let height = (note.userInfo?[UIWindow.keyboardFrameEndUserInfoKey] as? CGRect ?? .zero).size.height
//
//            print("Received \(note.name.rawValue) with height \(height)")
//            return height
//    }

    var body: some View {
        content
            .onReceive(keyboardChangePublisher) { self.keyboardHeight = $0 }
            .padding(.bottom, keyboardHeight)
            .animation(.default)
    }

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

struct KeyboardHost_Previews: PreviewProvider {
    static var previews: some View {
        KeyboardHost {
            TextField("TextField", text: .constant("Preview text field"))
        }
    }
}

สิ่งนี้ดัดแปลงมาจากสิ่งที่ @kontiki สร้างขึ้น ฉันเปิดใช้งานในแอปภายใต้เบต้า 8 / เมล็ดพันธุ์ GM โดยที่ฟิลด์ที่ต้องเลื่อนเป็นส่วนหนึ่งของแบบฟอร์มภายใน NavigationView นี่คือ KeyboardGuardian:

//
//  KeyboardGuardian.swift
//
//  /programming/56491881/move-textfield-up-when-thekeyboard-has-appeared-by-using-swiftui-ios
//

import SwiftUI
import Combine

/// The purpose of KeyboardGuardian, is to keep track of keyboard show/hide events and
/// calculate how much space the view needs to be shifted.
final class KeyboardGuardian: ObservableObject {
    let objectWillChange = ObservableObjectPublisher() // PassthroughSubject<Void, Never>()

    public var rects: Array<CGRect>
    public var keyboardRect: CGRect = CGRect()

    // keyboardWillShow notification may be posted repeatedly,
    // this flag makes sure we only act once per keyboard appearance
    private var keyboardIsHidden = true

    var slide: CGFloat = 0 {
        didSet {
            objectWillChange.send()
        }
    }

    public var showField: Int = 0 {
        didSet {
            updateSlide()
        }
    }

    init(textFieldCount: Int) {
        self.rects = Array<CGRect>(repeating: CGRect(), count: textFieldCount)

        NotificationCenter.default.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(keyBoardDidHide(notification:)), name: UIResponder.keyboardDidHideNotification, object: nil)

    }

    @objc func keyBoardWillShow(notification: Notification) {
        if keyboardIsHidden {
            keyboardIsHidden = false
            if let rect = notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect {
                keyboardRect = rect
                updateSlide()
            }
        }
    }

    @objc func keyBoardDidHide(notification: Notification) {
        keyboardIsHidden = true
        updateSlide()
    }

    func updateSlide() {
        if keyboardIsHidden {
            slide = 0
        } else {
            slide = -keyboardRect.size.height
        }
    }
}

จากนั้นฉันใช้ enum เพื่อติดตามสล็อตในอาร์เรย์ rects และจำนวนทั้งหมด:

enum KeyboardSlots: Int {
    case kLogPath
    case kLogThreshold
    case kDisplayClip
    case kPingInterval
    case count
}

KeyboardSlots.count.rawValueคือความจุอาร์เรย์ที่จำเป็น อื่น ๆ เป็น rawValue ให้ดัชนีที่เหมาะสมที่คุณจะใช้สำหรับการเรียก. background (GeometryGetter)

ด้วยการตั้งค่าดังกล่าวมุมมองจะไปที่ KeyboardGuardian ด้วยสิ่งนี้:

@ObservedObject private var kGuardian = KeyboardGuardian(textFieldCount: SettingsFormBody.KeyboardSlots.count.rawValue)

การเคลื่อนไหวที่แท้จริงเป็นดังนี้:

.offset(y: kGuardian.slide).animation(.easeInOut(duration: 1))

แนบกับมุมมอง ในกรณีของฉันมันเชื่อมต่อกับ NavigationView ทั้งหมดดังนั้นการประกอบทั้งหมดจึงเลื่อนขึ้นเมื่อแป้นพิมพ์ปรากฏขึ้น

ฉันยังไม่ได้แก้ปัญหาในการรับแถบเครื่องมือเสร็จสิ้นหรือปุ่มย้อนกลับบนแป้นพิมพ์ทศนิยมด้วย SwiftUI ฉันจึงใช้สิ่งนี้เพื่อซ่อนมันในการแตะที่อื่นแทน:

struct DismissingKeyboard: ViewModifier {
    func body(content: Content) -> some View {
        content
            .onTapGesture {
                let keyWindow = UIApplication.shared.connectedScenes
                        .filter({$0.activationState == .foregroundActive})
                        .map({$0 as? UIWindowScene})
                        .compactMap({$0})
                        .first?.windows
                        .filter({$0.isKeyWindow}).first
                keyWindow?.endEditing(true)                    
        }
    }
}

คุณแนบเข้ากับมุมมองเป็น

.modifier(DismissingKeyboard())

มุมมองบางอย่าง (เช่นตัวเลือก) ไม่ชอบการแนบนั้นดังนั้นคุณอาจต้องมีความละเอียดในการแนบตัวปรับแต่งแทนที่จะตบที่มุมมองด้านนอกสุด

ขอบคุณมากที่ @kontiki สำหรับการทำงานหนัก คุณจะยังคงต้องใช้ GeometryGetter ของเขาด้านบน (ไม่ใช่ฉันไม่ได้ทำงานเพื่อแปลงเป็นค่ากำหนดเช่นกัน) ตามที่เขาแสดงในตัวอย่าง

วิธีแก้ปัญหาสองสามข้อข้างต้นมีปัญหาบางประการและไม่จำเป็นต้องเป็นแนวทางที่ "สะอาดที่สุด" ด้วยเหตุนี้ฉันจึงได้ปรับเปลี่ยนบางสิ่งสำหรับการใช้งานด้านล่าง

extension View {
    func onKeyboard(_ keyboardYOffset: Binding<CGFloat>) -> some View {
        return ModifiedContent(content: self, modifier: KeyboardModifier(keyboardYOffset))
    }
}

struct KeyboardModifier: ViewModifier {
    @Binding var keyboardYOffset: CGFloat
    let keyboardWillAppearPublisher = NotificationCenter.default.publisher(for: UIResponder.keyboardWillShowNotification)
    let keyboardWillHidePublisher = NotificationCenter.default.publisher(for: UIResponder.keyboardWillHideNotification)

    init(_ offset: Binding<CGFloat>) {
        _keyboardYOffset = offset
    }

    func body(content: Content) -> some View {
        return content.offset(x: 0, y: -$keyboardYOffset.wrappedValue)
            .animation(.easeInOut(duration: 0.33))
            .onReceive(keyboardWillAppearPublisher) { notification in
                let keyWindow = UIApplication.shared.connectedScenes
                    .filter { $0.activationState == .foregroundActive }
                    .map { $0 as? UIWindowScene }
                    .compactMap { $0 }
                    .first?.windows
                    .filter { $0.isKeyWindow }
                    .first

                let yOffset = keyWindow?.safeAreaInsets.bottom ?? 0

                let keyboardFrame = (notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue ?? .zero

                self.$keyboardYOffset.wrappedValue = keyboardFrame.height - yOffset
        }.onReceive(keyboardWillHidePublisher) { _ in
            self.$keyboardYOffset.wrappedValue = 0
        }
    }
}

struct RegisterView: View {
    @State var name = ""
    @State var keyboardYOffset: CGFloat = 0

    var body: some View {

        VStack {
            WelcomeMessageView()
            TextField("Type your name...", text: $name).bordered()
        }.onKeyboard($keyboardYOffset)
            .background(WelcomeBackgroundImage())
            .padding()
    }
}

ฉันชอบแนวทางที่สะอาดกว่าและย้ายความรับผิดชอบไปยังมุมมองที่สร้างขึ้น (ไม่ใช่ตัวปรับแต่ง) ในการชดเชยเนื้อหา แต่ดูเหมือนว่าฉันจะไม่สามารถให้ผู้เผยแพร่ทริกเกอร์ได้อย่างถูกต้องเมื่อย้ายโค้ดออฟเซ็ตไปที่มุมมอง ...

นอกจากนี้โปรดทราบว่าผู้เผยแพร่โฆษณาต้องถูกใช้ในอินสแตนซ์นี้เนื่องจากfinal classปัจจุบันเกิดข้อผิดพลาดที่ไม่ทราบสาเหตุ (แม้ว่าจะเป็นไปตามข้อกำหนดของอินเทอร์เฟซก็ตาม) และ ScrollView โดยรวมเป็นแนวทางที่ดีที่สุดเมื่อใช้โค้ดออฟเซ็ต

คำตอบเหล่านี้จำนวนมากดูเหมือนจะป่องจริงๆ หากคุณใช้ SwiftUI คุณอาจใช้ประโยชน์จาก Combine ได้เช่นกัน

สร้างKeyboardResponderตามที่แสดงด้านล่างจากนั้นคุณสามารถใช้ตามที่แสดงไว้ก่อนหน้านี้

อัปเดตสำหรับ iOS 14

import Combine
import UIKit

final class KeyboardResponder: ObservableObject {

    @Published var keyboardHeight: CGFloat = 0

    init() {
        NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)
            .compactMap { notification in
                (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue.height
            }
            .receive(on: DispatchQueue.main)
            .assign(to: \.keyboardHeight)
    }
}


struct ExampleView: View {
    @ObservedObject private var keyboardResponder = KeyboardResponder()
    @State private var text: String = ""

    var body: some View {
        VStack {
            Text(text)
            Spacer()
            TextField("Example", text: $text)
        }
        .padding(.bottom, keyboardResponder.keyboardHeight)
    }
}

ฉันไม่แน่ใจว่า API การเปลี่ยนแปลง / แอนิเมชั่นสำหรับ SwiftUI นั้นสมบูรณ์หรือไม่ แต่คุณสามารถใช้CGAffineTransformกับไฟล์.transformEffect

สร้างวัตถุแป้นพิมพ์ที่สังเกตได้ด้วยคุณสมบัติที่เผยแพร่ดังนี้:

    final class KeyboardResponder: ObservableObject {
    private var notificationCenter: NotificationCenter
    @Published var readyToAppear = false

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

    deinit {
        notificationCenter.removeObserver(self)
    }

    @objc func keyBoardWillShow(notification: Notification) {
        readyToAppear = true
    }

    @objc func keyBoardWillHide(notification: Notification) {
        readyToAppear = false
    }

}

จากนั้นคุณสามารถใช้คุณสมบัตินั้นเพื่อจัดเรียงมุมมองของคุณใหม่ดังนี้:

    struct ContentView : View {
    @State var textfieldText: String = ""
    @ObservedObject private var keyboard = KeyboardResponder()

    var body: some View {
        return self.buildContent()
    }

    func buildContent() -> some View {
        let mainStack = VStack {
            TextField("TextField1", text: self.$textfieldText)
            TextField("TextField2", text: self.$textfieldText)
            TextField("TextField3", text: self.$textfieldText)
            TextField("TextField4", text: self.$textfieldText)
            TextField("TextField5", text: self.$textfieldText)
            TextField("TextField6", text: self.$textfieldText)
            TextField("TextField7", text: self.$textfieldText)
        }
        return Group{
            if self.keyboard.readyToAppear {
                mainStack.transformEffect(CGAffineTransform(translationX: 0, y: -200))
                    .animation(.spring())
            } else {
                mainStack
            }
        }
    }
}

หรือง่ายกว่า

VStack {
        TextField("TextField1", text: self.$textfieldText)
        TextField("TextField2", text: self.$textfieldText)
        TextField("TextField3", text: self.$textfieldText)
        TextField("TextField4", text: self.$textfieldText)
        TextField("TextField5", text: self.$textfieldText)
        TextField("TextField6", text: self.$textfieldText)
        TextField("TextField7", text: self.$textfieldText)
    }.transformEffect(keyboard.readyToAppear ? CGAffineTransform(translationX: 0, y: -50) : .identity)
            .animation(.spring())

Xcode 12 beta 4 เพิ่มตัวปรับมุมมองใหม่ignoresSafeAreaที่คุณสามารถใช้เพื่อหลีกเลี่ยงแป้นพิมพ์ได้แล้ว

.ignoresSafeArea([], edges: [])

ซึ่งจะหลีกเลี่ยงแป้นพิมพ์และขอบพื้นที่ปลอดภัยทั้งหมด คุณสามารถตั้งค่าพารามิเตอร์แรกเป็น.keyboardถ้าคุณไม่ต้องการหลีกเลี่ยง มีความแปลกประหลาดอยู่บ้างอย่างน้อยก็ในการตั้งค่าลำดับชั้นมุมมองของฉัน แต่ดูเหมือนว่านี่เป็นวิธีที่ Apple ต้องการให้เราหลีกเลี่ยงแป้นพิมพ์

คัดลอกคำตอบจากที่นี่: TextField อยู่ด้านบนแป้นพิมพ์เสมอด้วย SwiftUI

ฉันได้ลองใช้วิธีต่างๆแล้ว แต่ไม่มีวิธีใดที่ได้ผลสำหรับฉัน ด้านล่างนี้เป็นอุปกรณ์เดียวที่ใช้งานได้กับอุปกรณ์ต่างๆ

เพิ่มนามสกุลนี้ในไฟล์:

import SwiftUI
import Combine

extension View {
    func keyboardSensible(_ offsetValue: Binding<CGFloat>) -> some View {
        
        return self
            .padding(.bottom, offsetValue.wrappedValue)
            .animation(.spring())
            .onAppear {
                NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillShowNotification, object: nil, queue: .main) { notification in
                    
                    let keyWindow = UIApplication.shared.connectedScenes
                        .filter({$0.activationState == .foregroundActive})
                        .map({$0 as? UIWindowScene})
                        .compactMap({$0})
                        .first?.windows
                        .filter({$0.isKeyWindow}).first
                    
                    let bottom = keyWindow?.safeAreaInsets.bottom ?? 0
                    
                    let value = notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect
                    let height = value.height
                    
                    offsetValue.wrappedValue = height - bottom
                }
                
                NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, object: nil, queue: .main) { _ in
                    offsetValue.wrappedValue = 0
                }
        }
    }
}

ในมุมมองของคุณคุณต้องมีตัวแปรเพื่อผูก offsetValue:

struct IncomeView: View {

  @State private var offsetValue: CGFloat = 0.0

  var body: some View { 
    
    VStack {
     //...       
    }
    .keyboardSensible($offsetValue)
  }
}

ดังที่ Mark Krenek และ Heiko ได้ชี้ให้เห็น Apple ดูเหมือนว่าจะแก้ไขปัญหานี้ใน Xcode 12 beta 4 เป็นเวลานานสิ่งต่างๆกำลังดำเนินไปอย่างรวดเร็ว ตามบันทึกประจำรุ่นสำหรับ Xcode 12 beta 5 ที่เผยแพร่เมื่อวันที่ 18 สิงหาคม 2020 "Form, List และ TextEditor ไม่ได้ซ่อนเนื้อหาไว้ด้านหลังแป้นพิมพ์อีกต่อไป (66172025)" ฉันเพิ่งดาวน์โหลดและทำการทดสอบอย่างรวดเร็วในโปรแกรมจำลองเบต้า 5 (iPhone SE2) ด้วย Form container ในแอปที่ฉันเริ่มเมื่อไม่กี่วันที่ผ่านมา

ตอนนี้ "ใช้งานได้" สำหรับTextField TextFieldSwiftUI จะจัดเตรียมช่องว่างด้านล่างที่เหมาะสมให้กับแบบฟอร์มการห่อหุ้มโดยอัตโนมัติเพื่อให้มีที่ว่างสำหรับแป้นพิมพ์ และมันจะเลื่อน Form ขึ้นโดยอัตโนมัติเพื่อแสดง TextField เหนือแป้นพิมพ์ ตอนนี้คอนเทนเนอร์ ScrollView ทำงานได้ดีเมื่อคีย์บอร์ดปรากฏขึ้นเช่นกัน

แต่เป็นАндрейПервушинชี้ให้เห็นในความคิดเห็นมีปัญหากับ TextEditor เบต้า 5 และ 6 จะจัดเตรียมช่องว่างด้านล่างที่เหมาะสมให้กับแบบฟอร์มการห่อหุ้มโดยอัตโนมัติเพื่อให้มีที่ว่างสำหรับแป้นพิมพ์ แต่จะไม่เลื่อนแบบฟอร์มขึ้นโดยอัตโนมัติ แป้นพิมพ์จะครอบคลุม TextEditor แตกต่างจาก TextField คือผู้ใช้ต้องเลื่อนแบบฟอร์มเพื่อให้ TextEditor มองเห็นได้ ฉันจะยื่นรายงานข้อบกพร่อง บางที Beta 7 อาจแก้ไขได้ เฉียดฉิว …

https://developer.apple.com/documentation/ios-ipados-release-notes/ios-ipados-14-beta-release-notes/

การใช้งาน:

import SwiftUI

var body: some View {
    ScrollView {
        VStack {
          /*
          TextField()
          */
        }
    }.keyboardSpace()
}

รหัส:

import SwiftUI
import Combine

let keyboardSpaceD = KeyboardSpace()
extension View {
    func keyboardSpace() -> some View {
        modifier(KeyboardSpace.Space(data: keyboardSpaceD))
    }
}

class KeyboardSpace: ObservableObject {
    var sub: AnyCancellable?
    
    @Published var currentHeight: CGFloat = 0
    var heightIn: CGFloat = 0 {
        didSet {
            withAnimation {
                if UIWindow.keyWindow != nil {
                    //fix notification when switching from another app with keyboard
                    self.currentHeight = heightIn
                }
            }
        }
    }
    
    init() {
        subscribeToKeyboardEvents()
    }
    
    private let keyboardWillOpen = NotificationCenter.default
        .publisher(for: UIResponder.keyboardWillShowNotification)
        .map { $0.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect }
        .map { $0.height - (UIWindow.keyWindow?.safeAreaInsets.bottom ?? 0) }
    
    private let keyboardWillHide =  NotificationCenter.default
        .publisher(for: UIResponder.keyboardWillHideNotification)
        .map { _ in CGFloat.zero }
    
    private func subscribeToKeyboardEvents() {
        sub?.cancel()
        sub = Publishers.Merge(keyboardWillOpen, keyboardWillHide)
            .subscribe(on: RunLoop.main)
            .assign(to: \.self.heightIn, on: self)
    }
    
    deinit {
        sub?.cancel()
    }
    
    struct Space: ViewModifier {
        @ObservedObject var data: KeyboardSpace
        
        func body(content: Content) -> some View {
            VStack(spacing: 0) {
                content
                
                Rectangle()
                    .foregroundColor(Color(.clear))
                    .frame(height: data.currentHeight)
                    .frame(maxWidth: .greatestFiniteMagnitude)

            }
        }
    }
}

extension UIWindow {
    static var keyWindow: UIWindow? {
        let keyWindow = UIApplication.shared.connectedScenes
            .filter({$0.activationState == .foregroundActive})
            .map({$0 as? UIWindowScene})
            .compactMap({$0})
            .first?.windows
            .filter({$0.isKeyWindow}).first
        return keyWindow
    }
}

การจัดการTabViewของ

ฉันชอบคำตอบของ Benjamin Kindleแต่ไม่รองรับ TabViews นี่คือการปรับรหัสของเขาสำหรับการจัดการ TabViews:

1. เพิ่มส่วนขยายเพื่อUITabViewจัดเก็บขนาดของ tabView เมื่อกำหนดเฟรม เราสามารถเก็บสิ่งนี้ไว้ในตัวแปรคงที่ได้เนื่องจากโดยปกติแล้วจะมีเพียง tabView เดียวในโครงการ (หากของคุณมีมากกว่าหนึ่งรายการคุณจะต้องปรับเปลี่ยน)

extension UITabBar {

    static var size: CGSize = .zero

    open override var frame: CGRect {
        get {
            super.frame
        } set {
            UITabBar.size = newValue.size
            super.frame = newValue
        }
    }
}

2. คุณจะต้องเปลี่ยนเขาonReceiveที่ด้านล่างของKeyboardHostมุมมองเพื่อพิจารณาความสูงของแถบแท็บ:

.onReceive(showPublisher.merge(with: hidePublisher)) { (height) in
            self.keyboardHeight = max(height - UITabBar.size.height, 0)
        }

3. เท่านี้เอง! ง่ายสุด ๆ 🎉.

ฉันใช้วิธีการที่แตกต่างกันโดยสิ้นเชิงโดยการขยายUIHostingControllerและปรับadditionalSafeAreaInsets:

class MyHostingController<Content: View>: UIHostingController<Content> {
    override init(rootView: Content) {
        super.init(rootView: rootView)
    }

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

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(keyboardDidShow(_:)), 
                                               name: UIResponder.keyboardDidShowNotification,
                                               object: nil)
        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(keyboardWillHide), 
                                               name: UIResponder.keyboardWillHideNotification, 
                                               object: nil)
    }       

    @objc func keyboardDidShow(_ notification: Notification) {
        guard let info:[AnyHashable: Any] = notification.userInfo,
            let frame = info[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else {
                return
        }

        // set the additionalSafeAreaInsets
        let adjustHeight = frame.height - (self.view.safeAreaInsets.bottom - self.additionalSafeAreaInsets.bottom)
        self.additionalSafeAreaInsets = UIEdgeInsets(top: 0, left: 0, bottom: adjustHeight, right: 0)

        // now try to find a UIResponder inside a ScrollView, and scroll
        // the firstResponder into view
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.1) { 
            if let firstResponder = UIResponder.findFirstResponder() as? UIView,
                let scrollView = firstResponder.parentScrollView() {
                // translate the firstResponder's frame into the scrollView's coordinate system,
                // with a little vertical padding
                let rect = firstResponder.convert(firstResponder.frame, to: scrollView)
                    .insetBy(dx: 0, dy: -15)
                scrollView.scrollRectToVisible(rect, animated: true)
            }
        }
    }

    @objc func keyboardWillHide() {
        self.additionalSafeAreaInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
    }
}

/// IUResponder extension for finding the current first responder
extension UIResponder {
    private struct StaticFirstResponder {
        static weak var firstResponder: UIResponder?
    }

    /// find the current first responder, or nil
    static func findFirstResponder() -> UIResponder? {
        StaticFirstResponder.firstResponder = nil
        UIApplication.shared.sendAction(
            #selector(UIResponder.trap),
            to: nil, from: nil, for: nil)
        return StaticFirstResponder.firstResponder
    }

    @objc private func trap() {
        StaticFirstResponder.firstResponder = self
    }
}

/// UIView extension for finding the receiver's parent UIScrollView
extension UIView {
    func parentScrollView() -> UIScrollView? {
        if let scrollView = self.superview as? UIScrollView {
            return scrollView
        }

        return superview?.parentScrollView()
    }
}

แล้วเปลี่ยนSceneDelegateมาใช้MyHostingControllerแทนUIHostingController .

เมื่อเสร็จแล้วฉันไม่ต้องกังวลกับแป้นพิมพ์ภายในรหัส SwiftUI ของฉัน

(หมายเหตุ: ฉันยังใช้สิ่งนี้ไม่เพียงพอเพื่อให้เข้าใจถึงผลกระทบใด ๆ ของการทำสิ่งนี้!)

นี่คือวิธีที่ฉันจัดการกับคีย์บอร์ดใน SwiftUI สิ่งที่ต้องจำไว้ก็คือการคำนวณบน VStack ที่แนบมา

คุณใช้บน View เป็น Modifier ทางนี้:

struct LogInView: View {

  var body: some View {
    VStack {
      // Your View
    }
    .modifier(KeyboardModifier())
  }
}

ดังนั้นในการมาถึงตัวปรับแต่งนี้ก่อนอื่นให้สร้างส่วนขยายของ UIResponder เพื่อรับตำแหน่ง TextField ที่เลือกใน VStack:

import UIKit

// MARK: Retrieve TextField first responder for keyboard
extension UIResponder {

  private static weak var currentResponder: UIResponder?

  static var currentFirstResponder: UIResponder? {
    currentResponder = nil
    UIApplication.shared.sendAction(#selector(UIResponder.findFirstResponder),
                                    to: nil, from: nil, for: nil)
    return currentResponder
  }

  @objc private func findFirstResponder(_ sender: Any) {
    UIResponder.currentResponder = self
  }

  // Frame of the superview
  var globalFrame: CGRect? {
    guard let view = self as? UIView else { return nil }
    return view.superview?.convert(view.frame, to: nil)
  }
}

ตอนนี้คุณสามารถสร้าง KeyboardModifier โดยใช้ Combine เพื่อหลีกเลี่ยงแป้นพิมพ์ที่ซ่อน TextField:

import SwiftUI
import Combine

// MARK: Keyboard show/hide VStack offset modifier
struct KeyboardModifier: ViewModifier {

  @State var offset: CGFloat = .zero
  @State var subscription = Set<AnyCancellable>()

  func body(content: Content) -> some View {
    GeometryReader { geometry in
      content
        .padding(.bottom, self.offset)
        .animation(.spring(response: 0.4, dampingFraction: 0.5, blendDuration: 1))
        .onAppear {

          NotificationCenter.default.publisher(for: UIResponder.keyboardWillHideNotification)
            .handleEvents(receiveOutput: { _ in self.offset = 0 })
            .sink { _ in }
            .store(in: &self.subscription)

          NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)
            .map(\.userInfo)
            .compactMap { ($0?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect)?.size.height }
            .sink(receiveValue: { keyboardHeight in
              let keyboardTop = geometry.frame(in: .global).height - keyboardHeight
              let textFieldBottom = UIResponder.currentFirstResponder?.globalFrame?.maxY ?? 0
              self.offset = max(0, textFieldBottom - keyboardTop * 2 - geometry.safeAreaInsets.bottom) })
        .store(in: &self.subscription) }
        .onDisappear {
          // Dismiss keyboard
          UIApplication.shared.windows
            .first { $0.isKeyWindow }?
            .endEditing(true)

          self.subscription.removeAll() }
    }
  }
}

สำหรับ iOS 14 (เบต้า 4) นั้นทำงานได้ค่อนข้างง่าย:

var body: some View {
    VStack {
        TextField(...)
    }
    .padding(.bottom, 0)
}

และขนาดของมุมมองจะปรับไปที่ด้านบนของแป้นพิมพ์ มีการปรับแต่งเพิ่มเติมอย่างแน่นอนด้วยเฟรม (.maxHeight: ... ) ฯลฯ คุณจะคิดออก

น่าเสียดายที่แป้นพิมพ์ลอยบน iPad ยังคงทำให้เกิดปัญหาเมื่อย้าย แต่วิธีแก้ปัญหาดังกล่าวข้างต้นก็เช่นกันและยังคงเป็นเบต้าฉันหวังว่าพวกเขาจะเข้าใจ

ขอบคุณ Apple ในที่สุด!

มุมมองของฉัน:

struct AddContactView: View {
    
    @Environment(\.presentationMode) var presentationMode : Binding<PresentationMode>
    
    @ObservedObject var addContactVM = AddContactVM()
    
    @State private var offsetValue: CGFloat = 0.0
    
    @State var firstName : String
    @State var lastName : String
    @State var sipAddress : String
    @State var phoneNumber : String
    @State var emailID : String
    
  
    var body: some View {
        
        
        VStack{
            
            Header(title: StringConstants.ADD_CONTACT) {
                
                self.presentationMode.wrappedValue.dismiss()
            }
            
           ScrollView(Axis.Set.vertical, showsIndicators: false){
            
            Image("contactAvatar")
                .padding(.top, 80)
                .padding(.bottom, 100)
                //.padding(.vertical, 100)
                //.frame(width: 60,height : 60).aspectRatio(1, contentMode: .fit)
            
            VStack(alignment: .center, spacing: 0) {
                
                
                TextFieldBorder(placeHolder: StringConstants.FIRST_NAME, currentText: firstName, imageName: nil)
                
                TextFieldBorder(placeHolder: StringConstants.LAST_NAME, currentText: lastName, imageName: nil)
                
                TextFieldBorder(placeHolder: StringConstants.SIP_ADDRESS, currentText: sipAddress, imageName: "sipPhone")
                TextFieldBorder(placeHolder: StringConstants.PHONE_NUMBER, currentText: phoneNumber, imageName: "phoneIcon")
                TextFieldBorder(placeHolder: StringConstants.EMAILID, currentText: emailID, imageName: "email")
                

            }
            
           Spacer()
            
        }
        .padding(.horizontal, 20)
        
            
        }
        .padding(.bottom, self.addContactVM.bottomPadding)
        .onAppear {
            
            NotificationCenter.default.addObserver(self.addContactVM, selector: #selector(self.addContactVM.keyboardWillShow(_:)), name: UIResponder.keyboardWillShowNotification, object: nil)
            
             NotificationCenter.default.addObserver(self.addContactVM, selector: #selector(self.addContactVM.keyboardWillHide(_:)), name: UIResponder.keyboardWillHideNotification, object: nil)
        }
        
    }
}

VM ของฉัน:

class AddContactVM : ObservableObject{
    
    @Published var contact : Contact = Contact(id: "", firstName: "", lastName: "", phoneNumbers: [], isAvatarAvailable: false, avatar: nil, emailID: "")
    
    @Published var bottomPadding : CGFloat = 0.0
    
    @objc  func keyboardWillShow(_ notification : Notification){
        
        if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
            let keyboardRectangle = keyboardFrame.cgRectValue
            let keyboardHeight = keyboardRectangle.height
            self.bottomPadding = keyboardHeight
        }
        
    }
    
    @objc  func keyboardWillHide(_ notification : Notification){
        
        
        self.bottomPadding = 0.0
        
    }
    
}

โดยทั่วไปการจัดการช่องว่างด้านล่างตามความสูงของแป้นพิมพ์

คำตอบที่สวยหรูที่สุดที่ฉันจัดการได้คล้ายกับวิธีแก้ปัญหาของ rraphael สร้างชั้นเรียนเพื่อฟังเหตุการณ์แป้นพิมพ์ แทนที่จะใช้ขนาดแป้นพิมพ์เพื่อแก้ไขช่องว่างภายในให้ส่งคืนค่าลบของขนาดแป้นพิมพ์และใช้ตัวปรับแต่ง. offset (y :) เพื่อปรับค่าออฟเซ็ตของคอนเทนเนอร์มุมมองด้านนอกสุด มันเคลื่อนไหวได้ดีพอและใช้ได้กับทุกมุมมอง