Verschieben Sie das Textfeld, wenn die Tastatur schnell angezeigt wird

217

Ich benutze Swift zum Programmieren mit iOS und ich benutze diesen Code, um das zu verschieben UITextField, aber es funktioniert nicht. Ich rufe die Funktion keyboardWillShowkorrekt auf, aber das Textfeld bewegt sich nicht. Ich benutze Autolayout.

override func viewDidLoad() {
    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
}

deinit {
    NSNotificationCenter.defaultCenter().removeObserver(self);
}

func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        //let contentInsets = UIEdgeInsets(top: 0, left: 0, bottom: keyboardSize.height, right: 0)

        var frame = self.ChatField.frame
        frame.origin.y = frame.origin.y - keyboardSize.height + 167
        self.chatField.frame = frame
        println("asdasd")
    }
}
Pedro Manfredi
quelle
Möglicherweise sind deinit und viewDidLoad nicht ausgeglichen.
Ricardo
Basierend auf Apples Dokumenten und persönlichen Erfahrungen. Hier ist mein Git-Repo mit UIScrollView zum Verschieben von TF: github.com/29satnam/MoveTextFieldWhenKeyboardAppearsSwift
Codetard

Antworten:

315

An den vorhandenen Antworten müssen einige Verbesserungen vorgenommen werden.

Erstens ist die UIKeyboardWillChangeFrameNotification wahrscheinlich die beste Benachrichtigung, da sie Änderungen behandelt, die nicht nur ein- / ausgeblendet werden, sondern auch aufgrund von Tastaturänderungen (Sprache, Verwendung von Tastaturen von Drittanbietern usw.) und Drehungen (beachten Sie jedoch den Kommentar unten, der angibt, dass die Tastatur ausgeblendet werden soll) auch zur Unterstützung der Hardware-Tastaturverbindung behandelt werden).

Zweitens können die Animationsparameter aus der Benachrichtigung abgerufen werden, um sicherzustellen, dass die Animationen ordnungsgemäß zusammengefügt werden.

Es gibt wahrscheinlich Optionen, um diesen Code etwas genauer zu bereinigen, insbesondere wenn Sie mit dem erzwungenen Auspacken des Wörterbuchcodes vertraut sind.

Swift 3

class MyViewController: UIViewController {

// This constraint ties an element at zero points from the bottom layout guide
@IBOutlet var keyboardHeightLayoutConstraint: NSLayoutConstraint?

override func viewDidLoad() {
    super.viewDidLoad()
    // Note that SO highlighting makes the new selector syntax (#selector()) look
    // like a comment but it isn't one
    NotificationCenter.default.addObserver(self,
        selector: #selector(self.keyboardNotification(notification:)),
        name: NSNotification.Name.UIKeyboardWillChangeFrame,
        object: nil)
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

@objc func keyboardNotification(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        let endFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
        let endFrameY = endFrame.origin.y ?? 0
        let duration:TimeInterval = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIViewAnimationOptions.curveEaseInOut.rawValue
        let animationCurve:UIViewAnimationOptions = UIViewAnimationOptions(rawValue: animationCurveRaw)
        if endFrameY >= UIScreen.main.bounds.size.height {
            self.keyboardHeightLayoutConstraint?.constant = 0.0
        } else {
            self.keyboardHeightLayoutConstraint?.constant = endFrame?.size.height ?? 0.0
        }
        UIView.animate(withDuration: duration,
                                   delay: TimeInterval(0),
                                   options: animationCurve,
                                   animations: { self.view.layoutIfNeeded() },
                                   completion: nil)
    }
}

(Bearbeitet, um Tastaturanimationen außerhalb des Bildschirms zu berücksichtigen, anstatt sie zu verkleinern, wie in @ Gabox 'großartigem Kommentar unten angegeben)

Swift 5

class MyViewController: UIViewController {

// This constraint ties an element at zero points from the bottom layout guide
@IBOutlet var keyboardHeightLayoutConstraint: NSLayoutConstraint?

override func viewDidLoad() {
    super.viewDidLoad()
    // Note that SO highlighting makes the new selector syntax (#selector()) look
    // like a comment but it isn't one
    NotificationCenter.default.addObserver(self,
        selector: #selector(self.keyboardNotification(notification:)),
        name: UIResponder.keyboardWillChangeFrameNotification,
        object: nil)
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

@objc func keyboardNotification(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        let endFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
        let endFrameY = endFrame?.origin.y ?? 0
        let duration:TimeInterval = (userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve:UIView.AnimationOptions = UIView.AnimationOptions(rawValue: animationCurveRaw)
        if endFrameY >= UIScreen.main.bounds.size.height {
            self.keyboardHeightLayoutConstraint?.constant = 0.0
        } else {
            self.keyboardHeightLayoutConstraint?.constant = endFrame?.size.height ?? 0.0
        }
        UIView.animate(withDuration: duration,
                                   delay: TimeInterval(0),
                                   options: animationCurve,
                                   animations: { self.view.layoutIfNeeded() },
                                   completion: nil)
    }
}
Joseph Lord
quelle
1
@ JosephLord nett. aber ich fand, dass dies nicht funktioniert, wenn sich die Tastatur versteckt, weil endFrame?.size.heightes nicht Null ist. Ich habe den Endrahmen als UIKeyboardFrameEndUserInfoKey = "NSRect: {{0, 1024}, {768, 264}}";. Lief auf iOS 8.3 iPad Simulator, Portrait. Xcode6.3 Beta4.
Hlung
8
Wenn sich die Tastatur nicht versteckt, versuchen Sie, diesen Code zu verwenden, wenn endFrame? .origin.y> = UIScreen.mainScreen (). bounds.size.height {self.keyboardHeightLayoutConstraint? .constant = 0.0} else {self.keyboardHeightLayoutConstraint? .constant = endFrame.size.height}
Gabriel Goncalves
3
keyBoardHeightLayoutConstraint ist eine in InterfaceBuilder definierte Einschränkung, die den unteren Rand der Ansicht einschränkt, die Sie in den unteren Layoutleitfaden oder den unteren Rand der Hauptansicht für den Ansichtscontroller verschieben / verkleinern möchten. Die Konstante wird anfänglich auf Null gesetzt und angepasst, um Platz für die Tastatur zu schaffen, wenn die Tastatur angezeigt wird oder ihre Größe ändert.
Joseph Lord
2
Beachten Sie, dass .UIKeyboardWillChangeFramedies nicht ausgelöst wird, wenn eine Hardwaretastatur angeschlossen ist, obwohl die iOS-Tastatur verschwindet. Sie müssen auch beobachten .UIKeyboardWillHide, um diesen Randfall zu fangen.
Jamesk
1
@ Sulthan funktioniert in Ordnung. Mein Problem ist, dass es etwas höher als das Keybaord wird. Gibt es eine Möglichkeit, dies zu beheben?
Pavlos
128

Wenn Sie das automatische Layout verwenden, haben Sie vermutlich die Einschränkung für den unteren Bereich auf Superview festgelegt . In diesem Fall müssen Sie lediglich den Wert der Einschränkung aktualisieren. So machen Sie es mit ein bisschen Animation.

func keyboardWasShown(notification: NSNotification) {
    let info = notification.userInfo!
    let keyboardFrame: CGRect = (info[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue()

    UIView.animateWithDuration(0.1, animations: { () -> Void in
        self.bottomConstraint.constant = keyboardFrame.size.height + 20
    })
}

Die fest codierte 20 wird nur hinzugefügt, um das Textfeld über der Tastatur ein wenig zu öffnen. Andernfalls würden sich der obere Rand der Tastatur und der untere Rand des Textfelds berühren.

Wenn die Tastatur geschlossen wird, setzen Sie den Wert der Einschränkung auf den ursprünglichen Wert zurück.

Isuru
quelle
1
Können Sie mir bitte erklären, wie ich es definiere? Vielen Dank! Ich kontrolliere immer alles auf dem Storyboard
Pedro Manfredi
4
bottomConstraint ist der Name, den ich der Einschränkung gegeben habe. Ich habe die Konstrante ausgewählt, gezogen und ein IBOutlet erstellt und diesen Namen angegeben. Sie können IBOutlets für Einschränkungen erstellen, genau wie Sie es mit anderen UI-Elementen wie Schaltflächen und Textfeldern tun können.
Isuru
2
Diese Antwort hat super funktioniert, außer dass die Animation sofort für mich passiert ist. Überprüfen Sie, wie ich Einschränkungsänderungen animiere. für das richtige Animieren.
Adam Johns
2
@ vinbhai4u Sie müssen sich für eine UIKeyboardWillShowNotificationBenachrichtigung registrieren . Schauen Sie sich den Code in der Frage des OP an.
Isuru
8
@AdamJohns Um die Einschränkungsänderung zu animieren, aktualisieren Sie die Konstante außerhalb von animateWithDurationund rufen Sie self.view.layoutIfNeeded()innerhalb des Animationsblocks auf.
Max
110

Eine einfache Lösung besteht darin, die Ansicht mit konstanter Tastaturhöhe nach oben zu verschieben.

override func viewDidLoad() {
   super.viewDidLoad()        
   NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
   NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
}

@objc func keyboardWillShow(sender: NSNotification) {
     self.view.frame.origin.y = -150 // Move view 150 points upward 
}

@objc func keyboardWillHide(sender: NSNotification) {
     self.view.frame.origin.y = 0 // Move view to original position  
}

Swift 5:

NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow(sender:)), name: UIResponder.keyboardWillShowNotification, object: nil);

NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide(sender:)), name: UIResponder.keyboardWillHideNotification, object: nil);
Saqib Omer
quelle
4
Ich mag diese einfache Lösung. Aber ich habe einen KeyboardShowing-Booleschen Wert hinzugefügt, da ich mehr als ein Textfeld verschoben habe. Ich bewege die Tastatur nur einmal, während sie angezeigt wird. Vielen Dank.
Ken
2
anstatt die Ansicht zu verschieben, verschieben Sie die textView
ericgu
1
Dadurch bleibt der y-Wert der Ansicht minus, wenn der Benutzer die Eingabesprache wechselt.
Jeffrey Neo
Anstatt die self.view zu ändern, die ich selbst.myConstraint Wert gemacht habe, funktioniert es, aber die Sache ist, dass die Ansicht (auf die die Einschränkung angewendet wird) weiter nach oben bewegt. Hat sich jemand diesem Problem gestellt?
Sashi
5
Anstatt Verwendung zu self.view.frame.origin.y -= 150verwenden self.view.frame.origin.y = -150und statt self.view.frame.origin.y += 150Verwendung self.view.frame.origin.y = 0. Dies verhindert, dass sich die Ansicht jedes Mal um 150 bewegt, wenn ein neues Feld berührt wird.
Gunwin
43

Um Ihre Ansicht beim Bearbeiten des Textfelds zu verschieben, versuchen Sie Folgendes: Ich habe Folgendes angewendet:

Option 1: - ** ** Aktualisierung in Swift 5.0 und iPhone X, XR, XS und XS Max Move mithilfe von NotificationCenter

  • Registrieren Sie diese Benachrichtigung in func viewWillAppear(_ animated: Bool)

  • Melden Sie diese Benachrichtigung in ab func viewWillDisappear(_ animated: Bool)

Hinweis: - Wenn Sie sich nicht abmelden, wird es von der untergeordneten Klasse aufgerufen und führt zum Absturz oder sonst.

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    NotificationCenter.default.addObserver( self, selector: #selector(keyboardWillShow(notification:)), name:  UIResponder.keyboardWillShowNotification, object: nil )
}
override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillShowNotification, object: nil)
}

@objc func keyboardWillShow( notification: Notification) {
    if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
        var newHeight: CGFloat
        let duration:TimeInterval = (notification.userInfo![UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = notification.userInfo![UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve:UIView.AnimationOptions = UIView.AnimationOptions(rawValue: animationCurveRaw)
        if #available(iOS 11.0, *) {
            newHeight = keyboardFrame.cgRectValue.height - self.view.safeAreaInsets.bottom
        } else {
            newHeight = keyboardFrame.cgRectValue.height
        }
        let keyboardHeight = newHeight  + 10 // **10 is bottom margin of View**  and **this newHeight will be keyboard height**
        UIView.animate(withDuration: duration,
                       delay: TimeInterval(0),
                       options: animationCurve,
                       animations: {
                        self.view.textViewBottomConstraint.constant = keyboardHeight **//Here you can manage your view constraints for animated show**
                        self.view.layoutIfNeeded() },
                       completion: nil)
    }
}

Option 2: - Es funktioniert gut

func textFieldDidBeginEditing(textField: UITextField) {
        self.animateViewMoving(up: true, moveValue: 100)
}
func textFieldDidEndEditing(textField: UITextField) {
        self.animateViewMoving(up: false, moveValue: 100)
}

func animateViewMoving (up:Bool, moveValue :CGFloat){
    var movementDuration:NSTimeInterval = 0.3
    var movement:CGFloat = ( up ? -moveValue : moveValue)
    UIView.beginAnimations( "animateView", context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)
    UIView.setAnimationDuration(movementDuration )
    self.view.frame = CGRectOffset(self.view.frame, 0,  movement)
    UIView.commitAnimations()
}

Ich habe diese Antwort von dieser Quelle erhalten. UITextField wird nach oben verschoben, wenn die Tastatur in Swift angezeigt wird

IN der Swift 4 ---

func textFieldDidBeginEditing(_ textField: UITextField) {
        animateViewMoving(up: true, moveValue: 100)
    }

    func textFieldDidEndEditing(_ textField: UITextField) {
        animateViewMoving(up: false, moveValue: 100)
    }
    func animateViewMoving (up:Bool, moveValue :CGFloat){
        let movementDuration:TimeInterval = 0.3
        let movement:CGFloat = ( up ? -moveValue : moveValue)
        UIView.beginAnimations( "animateView", context: nil)
        UIView.setAnimationBeginsFromCurrentState(true)
        UIView.setAnimationDuration(movementDuration ) 
        self.view.frame = self.view.frame.offsetBy(dx: 0, dy: movement)
        UIView.commitAnimations()
    }
Jogendra.Com
quelle
1
@ Jogendra.Com, Danke für deine harte Arbeit. Aber es funktioniert am besten auf iPhone 5,4s und 6. Aber wie kann ich es auf iPhone 6plus und iPad (höhere)
deaktivieren
Wenn Sie Option 1 verwenden, müssen Sie ein IBOutlet mit Einschränkungen hinzufügen. Sie erstellen eine Einschränkung, deren Größe Sie mithilfe des automatischen Layouts ändern möchten, und ziehen sie dann per Drag & Drop auf den Ansichtscontroller, um ein IBOutlet zu erstellen, auf das ich in der Animationsfunktion als self.iboutletConstraint.constant verweise. Auch dies stellt die Steckdose beim Ausblenden der Tastatur nicht neu ein. Ich habe dies behoben, indem ich die Einschränkung auf den ursprünglichen Wert zurückgesetzt habe.
Hammad Tariq
21

Ich liebe sauberen Swift-Code. Hier ist der engste Code, den ich finden könnte, um eine Textansicht mit der Tastatur nach oben / unten zu verschieben. Es funktioniert derzeit in einer iOS8 / 9 Swift 2-Produktions-App.

UPDATE (März 2016): Ich habe gerade meinen vorherigen Code so weit wie möglich verschärft. Außerdem gibt es hier eine Reihe beliebter Antworten, die die Tastaturhöhe und die Animationsparameter fest codieren. Das ist nicht nötig, ganz zu schweigen davon, dass die Zahlen in diesen Antworten nicht immer mit den tatsächlichen Werten übereinstimmen, die ich auf meinem 6s + iOS9 sehe (Tastaturhöhe 226, Dauer 0,25 und Animationskurve 7). In jedem Fall ist es fast kein zusätzlicher Code, um diese Werte direkt vom System zu erhalten. Siehe unten.

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "animateWithKeyboard:", name: UIKeyboardWillShowNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "animateWithKeyboard:", name: UIKeyboardWillHideNotification, object: nil)
}

func animateWithKeyboard(notification: NSNotification) {

    // Based on both Apple's docs and personal experience, 
    // I assume userInfo and its documented keys are available.
    // If you'd like, you can remove the forced unwrapping and add your own default values.

    let userInfo = notification.userInfo!
    let keyboardHeight = (userInfo[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue().height
    let duration = userInfo[UIKeyboardAnimationDurationUserInfoKey] as! Double
    let curve = userInfo[UIKeyboardAnimationCurveUserInfoKey] as! UInt
    let moveUp = (notification.name == UIKeyboardWillShowNotification)

    // baseContraint is your Auto Layout constraint that pins the
    // text view to the bottom of the superview.

    baseConstraint.constant = moveUp ? -keyboardHeight : 0

    let options = UIViewAnimationOptions(rawValue: curve << 16)
    UIView.animateWithDuration(duration, delay: 0, options: options,
        animations: {
            self.view.layoutIfNeeded()
        },
        completion: nil
    )

}

HINWEIS: Dieser Code deckt den meisten Kommentar / allgemeinen Fall ab. Möglicherweise ist jedoch mehr Code erforderlich, um unterschiedliche Ausrichtungen und / oder benutzerdefinierte Tastaturen zu handhaben. Hier finden Sie einen ausführlichen Artikel zur Arbeit mit der iOS-Tastatur. Wenn Sie jedes Szenario bewältigen müssen, kann dies hilfreich sein.

scootermg
quelle
Scheint Swift 1.1 zu sein und ich denke, dass es in Swift 1.2 nicht kompiliert werden kann, da es asfür Force Casts verwendet wird. as!mag funktionieren, aber wie Sie an anderer Stelle auf dieser Seite sehen können, vermeide ich das Wirken von Gewalt und das gewaltsame Auspacken.
Joseph Lord
Kompiliert jetzt in Swift 1.2. Und ich habe dem Code einen Kommentar hinzugefügt: das erzwungene Auspacken. Prost.
scootermg
Hoppla. Ich meinte Swift 2.
scootermg
Abhängig davon, wie Sie Ihre verknüpft haben baseConstraint, könnte es baseConstraint.constant = moveUp ? keyboardHeight : 0statt sein baseConstraint.constant = moveUp ? -keyboardHeight : 0.
Limfinity
15

Bearbeiten : Ich empfehle eine einfachere und sauberere Lösung. Ändern Sie einfach die Klasse der unteren Abstandsbeschränkung in KeyboardLayoutConstraint . Es wird automatisch auf die Tastaturhöhe erweitert.


Dies ist eine verbesserte Version der Antwort von @JosephLord.

Wie auf iOS 8.3 iPad Simulator, Portrait getestet. Xcode6.3 Beta4, ich fand, dass seine Antwort nicht funktioniert, wenn sich die Tastatur versteckt, weil UIKeyboardFrameEndUserInfoKeyist "NSRect: {{0, 1024}, {768, 264}}";. Die Höhe ist nie 0.

Dies geht zurück, um das Traditionelle zu verwenden UIKeyboardWillShowNotificationund UIKeyboardWillHideNotificationbesser zu erkennen, wann sich die Tastatur versteckt, anstatt sich auf die Höhe des Endrahmens zu verlassen. UIKeyboardWillShowNotificationwird auch gesendet, wenn der Tastaturrahmen geändert wird, sodass alle Anwendungsfälle abgedeckt werden sollen.

    // You have to set this up in storyboard first!. 
    // It's a vertical spacing constraint between view and bottom of superview.
    @IBOutlet weak var bottomSpacingConstraint: NSLayoutConstraint! 

    override func viewDidLoad() {
        super.viewDidLoad()

        NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardNotification:"), name:UIKeyboardWillShowNotification, object: nil);
        NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardNotification:"), name:UIKeyboardWillHideNotification, object: nil);
    }

    deinit {
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }

    func keyboardNotification(notification: NSNotification) {

        let isShowing = notification.name == UIKeyboardWillShowNotification

        if let userInfo = notification.userInfo {
            let endFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()
            let endFrameHeight = endFrame?.size.height ?? 0.0
            let duration:NSTimeInterval = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
            let animationCurveRawNSN = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
            let animationCurveRaw = animationCurveRawNSN?.unsignedLongValue ?? UIViewAnimationOptions.CurveEaseInOut.rawValue
            let animationCurve:UIViewAnimationOptions = UIViewAnimationOptions(rawValue: animationCurveRaw)
            self.bottomSpacingConstraint?.constant = isShowing ? endFrameHeight : 0.0
            UIView.animateWithDuration(duration,
                delay: NSTimeInterval(0),
                options: animationCurve,
                animations: { self.view.layoutIfNeeded() },
                completion: nil)
        }
    }
Hlung
quelle
Könnten Sie bitte Ihre Bearbeitung erklären? Ich konnte es nicht zum Laufen bringen. Ich habe eine UIScrollView mit einem Button unten. Ich habe die Klasse an der Randuntergrenze unten festgelegt.
schw4ndi
@ schw4ndi an welche Ansichten sind deine unteren Einschränkungen gebunden? Es sollte den unteren Rand der Bildlaufansicht mit dem unteren Rand der Übersichtsansicht verbinden.
Hlung
Oh danke, ich hatte die Einschränkung zwischen der Schaltfläche und der scrollView
schw4ndi
9

Ich arbeite mit Swift 4 und ich habe dieses Problem ohne zusätzliche untere Einschränkung gelöst. Schauen Sie, mein Code ist hier. Es funktioniert wirklich an meinem Fall

1) Fügen Sie Notification Observer in did load hinzu

override func viewDidLoad() {
        super.viewDidLoad()
        setupManager()
        // Do any additional setup after loading the view.
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
    }

2) Entfernen Sie Notification Observer wie

deinit {
        NotificationCenter.default.removeObserver(self)
    }

3) Fügen Sie Tastatur-Ein- / Ausblendmethoden wie hinzu

 @objc func keyboardWillShow(notification: NSNotification) {
            if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
                UIView.animate(withDuration: 0.1, animations: { () -> Void in
                    self.view.frame.origin.y -= keyboardSize.height
                    self.view.layoutIfNeeded()
                })
            }
        }

@objc func keyboardWillHide(notification: NSNotification) {
        if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
            UIView.animate(withDuration: 0.1, animations: { () -> Void in
                self.view.frame.origin.y += keyboardSize.height
                self.view.layoutIfNeeded()
            })
        }
    }

4) Fügen Sie einen Textfeild-Delegaten hinzu und fügen Sie touchBegan-Methoden hinzu. Verwenden Sie diese Option, um die Tastatur auszublenden, wenn Sie außerhalb des Textfeilds auf dem Bildschirm berühren

override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        view.endEditing(true)

    }
pansora abhay
quelle
muss seinUIKeyboardFrameEndUserInfoKey
Micro
1
NSNotification.Name.UIKeyboardWillShow Umbenannt wird UIResponder.keyboardWillShowNotificationauch UIKeyboardFrameBeginUserInfoKey zuUIResponder.keyboardFrameBeginUserInfoKey
SMJ
7

Dies ist eine verbesserte Version der Antwort von @JosephLord und @ Hlung. Es kann gelten, ob Sie eine Registerkarte haben oder nicht. Und es würde die Ansicht, die mit der Tastatur an die ursprüngliche Position verschoben wird, perfekt wiederherstellen.

// You have to set this up in storyboard first!. 
// It's a vertical spacing constraint between view and bottom of superview.
@IBOutlet weak var bottomSpacingConstraint: NSLayoutConstraint! 

override func viewDidLoad() {
        super.viewDidLoad()            

        //    Receive(Get) Notification
        NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardNotification:", name: UIKeyboardWillShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardNotification:", name: UIKeyboardWillHideNotification, object: nil)


        self.originalConstraint = self.keyboardHeightLayoutConstraint?.constant //for original coordinate.
}

func keyboardNotification(notification: NSNotification) {
        let isShowing = notification.name == UIKeyboardWillShowNotification

        var tabbarHeight: CGFloat = 0
        if self.tabBarController? != nil {
            tabbarHeight = self.tabBarController!.tabBar.frame.height
        }
        if let userInfo = notification.userInfo {
            let endFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()
            let duration:NSTimeInterval = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
            let animationCurveRawNSN = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
            let animationCurveRaw = animationCurveRawNSN?.unsignedLongValue ?? UIViewAnimationOptions.CurveEaseInOut.rawValue
            let animationCurve:UIViewAnimationOptions = UIViewAnimationOptions(rawValue: animationCurveRaw)
            self.keyboardHeightLayoutConstraint?.constant = isShowing ? (endFrame!.size.height - tabbarHeight) : self.originalConstraint!
            UIView.animateWithDuration(duration,
                delay: NSTimeInterval(0),
                options: animationCurve,
                animations: { self.view.layoutIfNeeded() },
                completion: nil)
        }
}
Jeff Gu Kang
quelle
6

Der einfachste Weg, der keinen Code erfordert:

  1. Laden Sie KeyboardLayoutConstraint.swift herunter und fügen Sie die Datei per Drag & Drop zu Ihrem Projekt hinzu, wenn Sie das Spring-Animationsframework noch nicht verwenden.
  2. Erstellen Sie in Ihrem Storyboard eine untere Einschränkung für das Objekt / die Ansicht / das Textfeld, wählen Sie die Einschränkung aus (doppelklicken Sie darauf) und ändern Sie im Identitätsinspektor die Klasse von NSLayoutConstraint in KeyboardLayoutConstraint.
  3. Getan!

Das Objekt bewegt sich synchron mit der Tastatur automatisch nach oben.

Gammachill
quelle
2
Tolle Lösung! Sie benötigen jedoch den sicheren Bereich. Unten als erstes Element der Einschränkung (hat bei mir nicht funktioniert, als es das zweite Element war). Und es funktionierte am besten mit der Konstante 0, da die Konstante beibehalten und angepasst wird, anstatt sie nur so weit zu bewegen, dass das Feld und die Tastatur angezeigt werden.
Mythlandia
Haben Sie die swift4-Version von KeyboardLayoutConstraint?
jeet.chanchawat
6

Ich habe ein Swift 3-Protokoll erstellt, um das Erscheinungsbild / Verschwinden der Tastatur zu behandeln

import UIKit

protocol KeyboardHandler: class {

var bottomConstraint: NSLayoutConstraint! { get set }

    func keyboardWillShow(_ notification: Notification)
    func keyboardWillHide(_ notification: Notification)
    func startObservingKeyboardChanges()
    func stopObservingKeyboardChanges()
}


extension KeyboardHandler where Self: UIViewController {

    func startObservingKeyboardChanges() {

        // NotificationCenter observers
        NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillShow, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillShow(notification)
        }

        // Deal with rotations
        NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillChangeFrame, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillShow(notification)
        }

        // Deal with keyboard change (emoji, numerical, etc.)
        NotificationCenter.default.addObserver(forName: NSNotification.Name.UITextInputCurrentInputModeDidChange, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillShow(notification)
        }

        NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillHide, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillHide(notification)
        }
    }


    func keyboardWillShow(_ notification: Notification) {

      let verticalPadding: CGFloat = 20 // Padding between the bottom of the view and the top of the keyboard

      guard let value = notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue else { return }
      let keyboardHeight = value.cgRectValue.height

      // Here you could have more complex rules, like checking if the textField currently selected is actually covered by the keyboard, but that's out of this scope.
      self.bottomConstraint.constant = keyboardHeight + verticalPadding

      UIView.animate(withDuration: 0.1, animations: { () -> Void in
          self.view.layoutIfNeeded()
      })
  }


  func keyboardWillHide(_ notification: Notification) {
      self.bottomConstraint.constant = 0

      UIView.animate(withDuration: 0.1, animations: { () -> Void in
          self.view.layoutIfNeeded()
      })
  }


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

}

Gehen Sie dann wie folgt vor, um es in einem UIViewController zu implementieren:

  • Lassen Sie den viewController diesem Protokoll entsprechen:

    class FormMailVC: UIViewControlle, KeyboardHandler {
  • Beobachten Sie Tastaturänderungen in viewWillAppear:

    // MARK: - View controller life cycle
    override func viewWillAppear(_ animated: Bool) {
      super.viewWillAppear(animated)
      startObservingKeyboardChanges()
    }
  • Beobachten Sie keine Tastaturänderungen mehr in viewWillDisappear:

    override func viewWillDisappear(_ animated: Bool) {
      super.viewWillDisappear(animated)
      stopObservingKeyboardChanges()
    }
  • Erstellen Sie im Storyboard ein IBOutlet für die unterste Einschränkung:

    // NSLayoutConstraints
    @IBOutlet weak var bottomConstraint: NSLayoutConstraint!

    (Ich empfehle, Ihre gesamte Benutzeroberfläche in eine "contentView" einzubetten und die untere Einschränkung von dieser contentView mit der unteren Layoutanleitung mit dieser Eigenschaft zu verknüpfen.) Untere Einschränkung der Inhaltsansicht

  • Ändern Sie die Einschränkungspriorität der obersten Einschränkung auf 250 (niedrig).

Obere Einschränkung der Inhaltsansicht

Auf diese Weise kann die gesamte Inhaltsansicht nach oben verschoben werden, wenn die Tastatur angezeigt wird. Die Priorität muss niedriger sein als jede andere Einschränkungspriorität in den Unteransichten, einschließlich Prioritäten für Inhaltsumarmung / Inhaltskomprimierungswiderstand.

  • Stellen Sie sicher, dass Ihr Autolayout über genügend Einschränkungen verfügt, um zu bestimmen, wie die Inhaltsansicht nach oben verschoben werden soll.

Möglicherweise müssen Sie hierfür eine Einschränkung "größer als gleich" hinzufügen: Einschränkung "größer als gleich"

Und los geht's! Ohne Tastatur

Mit Tastatur

Frédéric Adda
quelle
Es funktioniert, wenn Sie auch "Relation = Equal" ohne Warnungen setzen.
Valtoni Boaventura
Wenn Sie eine gleichwertige Beziehung herstellen, funktioniert dies möglicherweise nur in bestimmten Situationen. In anderen Fällen wird möglicherweise eine Warnung vor automatischen Layoutinkonsistenzen angezeigt. Es hängt von Ihrem eigenen Layout ab. Deshalb habe ich gesagt "Sie müssen vielleicht".
Frédéric Adda
Ok Frédéric, stimmte zu. War eine schöne Lösung!
Valtoni Boaventura
vermisstimport UIKit
Mirko
6

Eine solche einfache UIViewController Erweiterung kann verwendet werden

//MARK: - Observers
extension UIViewController {

    func addObserverForNotification(notificationName: String, actionBlock: (NSNotification) -> Void) {
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: nil, queue: NSOperationQueue.mainQueue(), usingBlock: actionBlock)
    }

    func removeObserver(observer: AnyObject, notificationName: String) {
        NSNotificationCenter.defaultCenter().removeObserver(observer, name: notificationName, object: nil)
    }
}

//MARK: - Keyboard observers
extension UIViewController {

    typealias KeyboardHeightClosure = (CGFloat) -> ()

    func addKeyboardChangeFrameObserver(willShow willShowClosure: KeyboardHeightClosure?,
        willHide willHideClosure: KeyboardHeightClosure?) {
            NSNotificationCenter.defaultCenter().addObserverForName(UIKeyboardWillChangeFrameNotification,
                object: nil, queue: NSOperationQueue.mainQueue(), usingBlock: { [weak self](notification) in
                    if let userInfo = notification.userInfo,
                        let frame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue(),
                        let duration = userInfo[UIKeyboardAnimationDurationUserInfoKey] as? Double,
                        let c = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? UInt,
                        let kFrame = self?.view.convertRect(frame, fromView: nil),
                        let kBounds = self?.view.bounds {

                            let animationType = UIViewAnimationOptions(rawValue: c)
                            let kHeight = kFrame.size.height
                            UIView.animateWithDuration(duration, delay: 0, options: animationType, animations: {
                                if CGRectIntersectsRect(kBounds, kFrame) { // keyboard will be shown
                                    willShowClosure?(kHeight)
                                } else { // keyboard will be hidden
                                    willHideClosure?(kHeight)
                                }
                                }, completion: nil)
                    } else {
                            print("Invalid conditions for UIKeyboardWillChangeFrameNotification")
                    }
            })
    }

    func removeKeyboardObserver() {
        removeObserver(self, notificationName: UIKeyboardWillChangeFrameNotification)
    }
}

Anwendungsbeispiel

override func viewWillDisappear(animated: Bool) {
        super.viewWillDisappear(animated)

        removeKeyboardObserver()
    }

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

    addKeyboardChangeFrameObserver(willShow: { [weak self](height) in
        //Update constraints here
        self?.view.setNeedsUpdateConstraints()
        }, willHide: { [weak self](height) in
        //Reset constraints here
        self?.view.setNeedsUpdateConstraints()
    })
}

Swift 4-Lösung

//MARK: - Observers
extension UIViewController {

  func addObserverForNotification(_ notificationName: Notification.Name, actionBlock: @escaping (Notification) -> Void) {
    NotificationCenter.default.addObserver(forName: notificationName, object: nil, queue: OperationQueue.main, using: actionBlock)
  }

  func removeObserver(_ observer: AnyObject, notificationName: Notification.Name) {
    NotificationCenter.default.removeObserver(observer, name: notificationName, object: nil)
  }
}

//MARK: - Keyboard handling
extension UIViewController {

  typealias KeyboardHeightClosure = (CGFloat) -> ()

  func addKeyboardChangeFrameObserver(willShow willShowClosure: KeyboardHeightClosure?,
                                      willHide willHideClosure: KeyboardHeightClosure?) {
    NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillChangeFrame,
                                           object: nil, queue: OperationQueue.main, using: { [weak self](notification) in
                                            if let userInfo = notification.userInfo,
                                              let frame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue,
                                              let duration = userInfo[UIKeyboardAnimationDurationUserInfoKey] as? Double,
                                              let c = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? UInt,
                                              let kFrame = self?.view.convert(frame, from: nil),
                                              let kBounds = self?.view.bounds {

                                              let animationType = UIViewAnimationOptions(rawValue: c)
                                              let kHeight = kFrame.size.height
                                              UIView.animate(withDuration: duration, delay: 0, options: animationType, animations: {
                                                if kBounds.intersects(kFrame) { // keyboard will be shown
                                                  willShowClosure?(kHeight)
                                                } else { // keyboard will be hidden
                                                  willHideClosure?(kHeight)
                                                }
                                              }, completion: nil)
                                            } else {
                                              print("Invalid conditions for UIKeyboardWillChangeFrameNotification")
                                            }
    })
  }

  func removeKeyboardObserver() {
    removeObserver(self, notificationName: NSNotification.Name.UIKeyboardWillChangeFrame)
  }
}

Swift 4.2

//MARK: - Keyboard handling
extension UIViewController {

    func addObserverForNotification(_ notificationName: Notification.Name, actionBlock: @escaping (Notification) -> Void) {
        NotificationCenter.default.addObserver(forName: notificationName, object: nil, queue: OperationQueue.main, using: actionBlock)
    }

    func removeObserver(_ observer: AnyObject, notificationName: Notification.Name) {
        NotificationCenter.default.removeObserver(observer, name: notificationName, object: nil)
    }

    typealias KeyboardHeightClosure = (CGFloat) -> ()

    func removeKeyboardObserver() {
        removeObserver(self, notificationName: UIResponder.keyboardWillChangeFrameNotification)
    }

    func addKeyboardChangeFrameObserver(willShow willShowClosure: KeyboardHeightClosure?,
                                        willHide willHideClosure: KeyboardHeightClosure?) {
        NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillChangeFrameNotification,
                                               object: nil, queue: OperationQueue.main, using: { [weak self](notification) in
                                                if let userInfo = notification.userInfo,
                                                    let frame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue,
                                                    let duration = userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double,
                                                    let c = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? UInt,
                                                    let kFrame = self?.view.convert(frame, from: nil),
                                                    let kBounds = self?.view.bounds {

                                                    let animationType = UIView.AnimationOptions(rawValue: c)
                                                    let kHeight = kFrame.size.height
                                                    UIView.animate(withDuration: duration, delay: 0, options: animationType, animations: {
                                                        if kBounds.intersects(kFrame) { // keyboard will be shown
                                                            willShowClosure?(kHeight)
                                                        } else { // keyboard will be hidden
                                                            willHideClosure?(kHeight)
                                                        }
                                                    }, completion: nil)
                                                } else {
                                                    print("Invalid conditions for UIKeyboardWillChangeFrameNotification")
                                                }
        })
    }
}
ale_stro
quelle
2
viel mehr "Swift" als die anderen Lösungen / funktioniert großartig / wiederverwendbar in jedem Controller, ohne alles neu zu schreiben -> definitiv die beste hier :)
Tib
Ich habe es versucht, aber keine Chance, wird UIScrollView benötigt oder was?
erdemgc
@erdemgc haben Sie Anwendungsbeispiel gesehen? Alles was Sie brauchen ist nur UIViewControlller + addKeyboardChangeFrameObserver und vergessen Sie dann nicht, es zu entfernen
ale_stro
Die removeKeyboardObserver()Methode hier entfernt den Beobachter nicht wirklich. Wenn Sie dies nicht aufrufen, wird Invalid conditions for UIKeyboardWillChangeFrameNotificationin der Konsole ein von der add-Methode angezeigt. Wenn Sie dies aufrufen, wird derselbe Fehler angezeigt, was bedeutet, dass der Beobachter nicht entfernt wird. In der Dokumentation heißt es: "Um die Registrierung von Beobachtungen aufzuheben, übergeben Sie das von dieser Methode zurückgegebene Objekt an removeObserver(_:)." Stattdessen speichern Sie das von dieser Methode zurückgegebene Objekt und übergeben es, wenn Sie den Beobachter entfernen möchten.
Huy-Anh Hoang
Sobald die Bildlaufansicht geladen ist, wird der Bindung ein Wert zugewiesen, und Sie können nicht erkennen, ob eine Tastatur ausgeblendet wird, wenn sich der Tastaturrahmen mit der Grenze überschneidet.
James Kim
5

Sie können diese Bibliothek verwenden und nur eine Codezeile in appDidFinishedLaunching und Sie sind fertig.

func application(application: UIApplication,didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    IQKeyboardManager.sharedManager().enable = true
    return true
}

IQKeyboardManager - Passen Sie die Ansicht an, wenn die Tastatur angezeigt wird. Link - https://github.com/hackiftekhar/IQKeyboardManager

Abdul Karim
quelle
4
struct MoveKeyboard {
    static let KEYBOARD_ANIMATION_DURATION : CGFloat = 0.3
    static let MINIMUM_SCROLL_FRACTION : CGFloat = 0.2;
    static let MAXIMUM_SCROLL_FRACTION : CGFloat = 0.8;
    static let PORTRAIT_KEYBOARD_HEIGHT : CGFloat = 216;
    static let LANDSCAPE_KEYBOARD_HEIGHT : CGFloat = 162;
}


  func textFieldDidBeginEditing(textField: UITextField) {
    let textFieldRect : CGRect = self.view.window!.convertRect(textField.bounds, fromView: textField)
    let viewRect : CGRect = self.view.window!.convertRect(self.view.bounds, fromView: self.view)

    let midline : CGFloat = textFieldRect.origin.y + 0.5 * textFieldRect.size.height
    let numerator : CGFloat = midline - viewRect.origin.y - MoveKeyboard.MINIMUM_SCROLL_FRACTION * viewRect.size.height
    let denominator : CGFloat = (MoveKeyboard.MAXIMUM_SCROLL_FRACTION - MoveKeyboard.MINIMUM_SCROLL_FRACTION) * viewRect.size.height
    var heightFraction : CGFloat = numerator / denominator

    if heightFraction < 0.0 {
        heightFraction = 0.0
    } else if heightFraction > 1.0 {
        heightFraction = 1.0
    }

    let orientation : UIInterfaceOrientation = UIApplication.sharedApplication().statusBarOrientation
    if (orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown) {
        animateDistance = floor(MoveKeyboard.PORTRAIT_KEYBOARD_HEIGHT * heightFraction)
    } else {
        animateDistance = floor(MoveKeyboard.LANDSCAPE_KEYBOARD_HEIGHT * heightFraction)
    }

    var viewFrame : CGRect = self.view.frame
    viewFrame.origin.y -= animateDistance

    UIView.beginAnimations(nil, context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)
    UIView.setAnimationDuration(NSTimeInterval(MoveKeyboard.KEYBOARD_ANIMATION_DURATION))

    self.view.frame = viewFrame

    UIView.commitAnimations()
}


func textFieldDidEndEditing(textField: UITextField) {
    var viewFrame : CGRect = self.view.frame
    viewFrame.origin.y += animateDistance

    UIView.beginAnimations(nil, context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)

    UIView.setAnimationDuration(NSTimeInterval(MoveKeyboard.KEYBOARD_ANIMATION_DURATION))

    self.view.frame = viewFrame

    UIView.commitAnimations()

}

Und schließlich, da wir Delegatenmethoden verwenden

func textFieldShouldReturn(textField: UITextField) -> Bool {
        textField.resignFirstResponder()
        return true
    }

Refactored von der Verwendung von Objective-C http://www.cocoawithlove.com/2008/10/sliding-uitextfields-around-to-avoid.html

Solomon Ayoola
quelle
Diese Lösung funktionierte für mich, obwohl ich einige zusätzliche Arbeiten var animateDistance: CGFloat!ausführen musste: Deklarieren Sie ein Plus Ich musste die UIKeyboardWillHideNotification verarbeiten, wenn der Benutzer die Tastaturtaste zum Ausblenden drückt.
Rhuantavan
4

Eine andere Lösung, die nicht von Autolayout, Einschränkungen oder Steckdosen abhängt. Was Sie brauchen, sind Ihre Felder in einer Bildlaufansicht.

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "makeSpaceForKeyboard:", name: UIKeyboardWillShowNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "makeSpaceForKeyboard:", name: UIKeyboardWillHideNotification, object: nil)
}

func makeSpaceForKeyboard(notification: NSNotification) {
    let info = notification.userInfo!
    let keyboardHeight:CGFloat = (info[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue().size.height
    let duration:Double = info[UIKeyboardAnimationDurationUserInfoKey] as! Double

    if notification.name == UIKeyboardWillShowNotification {
        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height - keyboardHeight
            self.view.frame = frame
        })
    } else {
        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height + keyboardHeight
            self.view.frame = frame
        })
    }

}
Simpa
quelle
1
Es zeigt schwarzen Bildschirm nach dem UIKeyboardWillShowNotificationAufruf.
Sachin Kumaram
4

Hier ist meine Version für eine Lösung für Swift 2.2:

Registrieren Sie sich zuerst für Benachrichtigungen zum Ein- / Ausblenden der Tastatur

NSNotificationCenter.defaultCenter().addObserver(self,
                                                 selector: #selector(MessageThreadVC.keyboardWillShow(_:)),
                                                 name: UIKeyboardWillShowNotification,
                                                 object: nil)
NSNotificationCenter.defaultCenter().addObserver(self,
                                                 selector: #selector(MessageThreadVC.keyboardWillHide(_:)),
                                                 name: UIKeyboardWillHideNotification,
                                                 object: nil)

Verschieben Sie dann in Methoden, die diesen Benachrichtigungen entsprechen, die Hauptansicht nach oben oder unten

func keyboardWillShow(sender: NSNotification) {
if let keyboardSize = (sender.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue() {
  self.view.frame.origin.y = -keyboardSize.height
  }
}

func keyboardWillHide(sender: NSNotification) {
self.view.frame.origin.y = 0
}

Der Trick liegt im Teil "keyboardWillShow", der jedes Mal Anrufe erhält, wenn die "QuickType-Vorschlagsleiste" erweitert oder reduziert wird. Dann setzen wir immer die y-Koordinate der Hauptansicht, die dem negativen Wert der gesamten Tastaturhöhe entspricht (mit oder ohne den Abschnitt "QuickType-Leiste").

Vergessen Sie am Ende nicht, Beobachter zu entfernen

deinit {
NSNotificationCenter.defaultCenter().removeObserver(self)
}
Pavle Mijatovic
quelle
3

Das Folgende ist eine einfache Lösung, bei der das Textfeld eine Einschränkung aufweist, die es an die untere Layoutanleitung bindet. Es fügt einfach die Tastaturhöhe zur Konstante der Einschränkung hinzu.

// This constraint ties the text field to the bottom layout guide
@IBOutlet var textFieldToBottomLayoutGuideConstraint: NSLayoutConstraint!

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardWillShow:", name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardWillHide:", name:UIKeyboardWillHideNotification, object: nil);
}

func keyboardWillShow(sender: NSNotification) {
    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.textFieldToBottomLayoutGuideConstraint?.constant += keyboardSize.height
    }
}

func keyboardWillHide(sender: NSNotification) {
    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.textFieldToBottomLayoutGuideConstraint?.constant -= keyboardSize.height
    }
}
Echessa
quelle
3

Nun, ich denke, ich bin vielleicht zu spät, aber ich habe eine andere einfache Version von Saqibs Antwort gefunden. Ich verwende Autolayout mit Einschränkungen. Ich habe eine kleine Ansicht in einer anderen Hauptansicht mit Feldern für Benutzername und Passwort. Anstatt die y-Koordinate der Ansicht zu ändern, speichere ich den ursprünglichen Einschränkungswert in einer Variablen und ändere die Konstante der Einschränkung auf einen bestimmten Wert. Nachdem die Tastatur geschlossen wurde, richte ich die Einschränkung auf den ursprünglichen Wert ein. Auf diese Weise wird das Problem vermieden, das Saqibs Antwort hat (Die Ansicht bewegt sich weiter nach oben und hört nicht auf). Unten ist mein Code ...

override func viewDidLoad() {
    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
    self.originalConstraint = self.centerYConstraint.constant
  }

  func keyboardWillShow(sender: NSNotification) {
    self.centerYConstraint.constant += 30
  }

  func keyboardWillHide(sender: NSNotification) {
    self.centerYConstraint.constant = self.originalConstraint
  }
Sashi
quelle
Überprüfen Sie innerhalb der keyboardWillShow- Methode die Bedingung, wenn self.centerYConstraint.constant == self.originalCenterYConstraint diese eine Codezeile zwischen dieser Bedingung hat. OriginalCenterYContraint ist der ursprüngliche Wert von centerYContraint, den ich in viewdidload speichere. Das hat bei mir funktioniert.
Sashi
3

Schnelle 4.x-Antwort, bei der die Antworten von @Joseph Lord und @Isuru zusammengeführt werden. bottomConstraintstellt die unterste Einschränkung der Ansicht dar, die Sie verschieben möchten.

override func viewDidLoad() {
    // Call super
    super.viewDidLoad()

    // Subscribe to keyboard notifications
    NotificationCenter.default.addObserver(self,
                                           selector: #selector(keyboardNotification(notification:)),
                                           name: UIResponder.keyboardWillChangeFrameNotification,
                                           object: nil)        
}


deinit {
    NotificationCenter.default.removeObserver(self)
}


@objc func keyboardNotification(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        // Get keyboard frame
        let keyboardFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue

        // Set new bottom constraint constant
        let bottomConstraintConstant = keyboardFrame.origin.y >= UIScreen.main.bounds.size.height ? 0.0 : keyboardFrame.size.height

        // Set animation properties
        let duration = (userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve = UIView.AnimationOptions(rawValue: animationCurveRaw)

        // Animate the view you care about
        UIView.animate(withDuration: duration, delay: 0, options: animationCurve, animations: {
            self.bottomConstraint.constant = bottomConstraintConstant
            self.view.layoutIfNeeded()
        }, completion: nil)
    }
}
Crashalot
quelle
2

Ich habe auf folgende Weise getan:

Dies ist nützlich, wenn die Textfeldübersicht angezeigt wird

class AdminLoginViewController: UIViewController,
UITextFieldDelegate{

    @IBOutlet weak var txtUserName: UITextField!
    @IBOutlet weak var txtUserPassword: UITextField!
    @IBOutlet weak var btnAdminLogin: UIButton!

    private var activeField : UIView?

    var param:String!
    var adminUser : Admin? = nil
    var kbHeight: CGFloat!

    override func viewDidLoad()
    {
        self.addKeyBoardObserver()
        self.addGestureForHideKeyBoard()
    }

    override func viewWillDisappear(animated: Bool) {
        super.viewWillDisappear(animated)
    }
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }

    func addGestureForHideKeyBoard()
    {
        let tapGesture = UITapGestureRecognizer(target: self, action: Selector("hideKeyboard"))
        tapGesture.cancelsTouchesInView = false
        view.addGestureRecognizer(tapGesture)
    }

    func hideKeyboard() {
        self.view.endEditing(true)
    }

    func addKeyBoardObserver(){

        NSNotificationCenter.defaultCenter().addObserver(self, selector: "willChangeKeyboardFrame:",
name:UIKeyboardWillShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: "willChangeKeyboardFrame:",
name:UIKeyboardWillHideNotification, object: nil)
    }

    func removeObserver(){
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }

    //MARK:- textfiled Delegate

    func textFieldShouldBeginEditing(textField: UITextField) -> Bool
    {
         activeField = textField

        return true
    }
    func textFieldShouldEndEditing(textField: UITextField) -> Bool
    {
        if activeField == textField
        {
            activeField = nil
        }

        return true
    }

    func textFieldShouldReturn(textField: UITextField) -> Bool {

        if txtUserName == textField
        {
            txtUserPassword.becomeFirstResponder()
        }
        else if (textField == txtUserPassword)
        {
            self.btnAdminLoginAction(nil)
        }
        return true;
    }

    func willChangeKeyboardFrame(aNotification : NSNotification)
    {
       if self.activeField != nil && self.activeField!.isFirstResponder()
    {
        if let keyboardSize =  (aNotification.userInfo![UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()
        {
            let dy = (self.activeField?.superview?.convertRect((self.activeField?.frame)!, toView: view).origin.y)!

            let height = (self.view.frame.size.height - keyboardSize.size.height)

            if dy > height
            {
                var frame = self.view.frame

                frame.origin.y = -((dy - height) + (self.activeField?.frame.size.height)! + 20)

                self.view.frame = frame
            }
        }
    }
    else
    {
        var frame = self.view.frame
        frame.origin.y = 0
        self.view.frame = frame
    }
    } }
Krishna Gawade
quelle
2
    func registerForKeyboardNotifications(){
        //Keyboard
        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(keyboardWasShown), name: UIKeyboardDidShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(keyboardWillBeHidden), name: UIKeyboardDidHideNotification, object: nil)


    }
    func deregisterFromKeyboardNotifications(){

        NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillHideNotification, object: nil)

    }
    func keyboardWasShown(notification: NSNotification){

        let userInfo: NSDictionary = notification.userInfo!
        let keyboardInfoFrame = userInfo.objectForKey(UIKeyboardFrameEndUserInfoKey)?.CGRectValue()

        let windowFrame:CGRect = (UIApplication.sharedApplication().keyWindow!.convertRect(self.view.frame, fromView:self.view))

        let keyboardFrame = CGRectIntersection(windowFrame, keyboardInfoFrame!)

        let coveredFrame = UIApplication.sharedApplication().keyWindow!.convertRect(keyboardFrame, toView:self.view)

        let contentInsets = UIEdgeInsetsMake(0, 0, (coveredFrame.size.height), 0.0)
        self.scrollViewInAddCase .contentInset = contentInsets;
        self.scrollViewInAddCase.scrollIndicatorInsets = contentInsets;
        self.scrollViewInAddCase.contentSize = CGSizeMake((self.scrollViewInAddCase.contentSize.width), (self.scrollViewInAddCase.contentSize.height))

    }
    /**
     this method will fire when keyboard was hidden

     - parameter notification: contains keyboard details
     */
    func keyboardWillBeHidden (notification: NSNotification) {

        self.scrollViewInAddCase.contentInset = UIEdgeInsetsZero
        self.scrollViewInAddCase.scrollIndicatorInsets = UIEdgeInsetsZero

    }
Kamalkumar.E
quelle
1
Verwenden Sie den obigen Code, um das Textfeld in Swift 2.2 über die Tastatur zu verschieben. Es funktioniert einwandfrei. Ich hoffe, es wird jemandem helfen.
Kamalkumar.E
1

Ich habe auf folgende Weise getan:

class SignInController: UIViewController , UITextFieldDelegate {

@IBOutlet weak var scrollView: UIScrollView!

// outlet declartion
@IBOutlet weak var signInTextView: UITextField!

var kbHeight: CGFloat!

/**
*
* @method viewDidLoad
*
*/

override func viewDidLoad() {
    super.viewDidLoad()

    self.signInTextView.delegate = self

}// end viewDidLoad

/**
*
* @method viewWillAppear
*
*/

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

    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name: UIKeyboardWillShowNotification, object: nil)

    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name: UIKeyboardWillHideNotification, object: nil)

}// end viewWillAppear

/**
*
* @method viewDidAppear
*
*/

override func viewDidAppear(animated: Bool) {
    super.viewDidAppear(animated)


}// end viewDidAppear

/**
*
* @method viewWillDisappear
*
*/
override func viewWillDisappear(animated: Bool) {
    super.viewWillDisappear(animated)
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

/**
*
* @method textFieldShouldReturn
* retun the keyboard value
*
*/

// MARK -
func textFieldShouldReturn(textField: UITextField) -> Bool {
    signInTextView.resignFirstResponder()
    return true;

}// end textFieldShouldReturn

// MARK - keyboardWillShow
func keyboardWillShow(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        if let keyboardSize =  (userInfo[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
            kbHeight = keyboardSize.height
            self.animateTextField(true)
        }
    }
}// end keyboardWillShow

// MARK - keyboardWillHide
func keyboardWillHide(notification: NSNotification) {
    self.animateTextField(false)
}// end keyboardWillHide

// MARK - animateTextField
func animateTextField(up: Bool) {
    var movement = (up ? -kbHeight : kbHeight)

    UIView.animateWithDuration(0.3, animations: {
        self.view.frame = CGRectOffset(self.view.frame, 0, movement)
    })
}// end animateTextField

/**
*
* @method didReceiveMemoryWarning
*
*/

override func didReceiveMemoryWarning() {
    super.didReceiveMemoryWarning()
    // Dispose of any resources that can be recreated.

}// end didReceiveMemoryWarning


}// end SignInController
Vinod Joshi
quelle
1

Wenn Sie wie ich sind, der alle oben genannten Lösungen ausprobiert hat und Ihr Problem immer noch nicht gelöst ist, habe ich eine großartige Lösung für Sie, die wie ein Zauber wirkt. Zunächst möchte ich einige Dinge über einige der oben genannten Lösungen klarstellen.

  1. In meinem Fall funktionierte IQkeyboardmanager nur, wenn kein automatisches Layout auf die Elemente angewendet wurde. Wenn es angewendet wird, funktioniert IQkeyboard Manager nicht so, wie wir denken.
  2. Gleiches gilt für die Aufwärtsbewegung von self.view.
  3. Ich habe einen objektiven c-Header mit einer schnellen Unterstützung für das Hochschieben von UITexfield nach oben geschrieben, wenn der Benutzer darauf klickt, um das Problem der Tastatur zu lösen, die das UITextfield abdeckt: https://github.com/coolvasanth/smart_keyboard .
  4. Wer über eine mittlere oder höhere Stufe in der Entwicklung von iOS-Apps verfügt, kann das Repository leicht verstehen und implementieren. Alles Gute
Vasanth
quelle
1

Hier ist eine generische Lösung für alle TextField-Schritte -

1) Erstellen Sie einen gemeinsamen ViewController, der von anderen ViewControllern erweitert wird

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)

}
 @objc func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        if self.view.frame.origin.y == 0 {
            self.view.frame.origin.y -= getMoveableDistance(keyboarHeight: keyboardSize.height)
        }
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    if self.view.frame.origin.y != 0 {
        self.view.frame.origin.y = 0
    }
}
deinit {
    NotificationCenter.default.removeObserver(self)
}

//get the distance to move up the main view for the focus textfiled
func getMoveableDistance(keyboarHeight : CGFloat) ->  CGFloat{
    var y:CGFloat = 0.0
    if let activeTF = getSelectedTextField(){
        var tfMaxY = activeTF.frame.maxY
        var containerView = activeTF.superview!
        while containerView.frame.maxY != self.view.frame.maxY{
            let contViewFrm = containerView.convert(activeTF.frame, to: containerView.superview)
            tfMaxY = tfMaxY + contViewFrm.minY
            containerView = containerView.superview!
        }
        let keyboardMinY = self.view.frame.height - keyboarHeight
        if tfMaxY > keyboardMinY{
            y = (tfMaxY - keyboardMinY) + 10.0
        }
    }

    return y
}

2) Erstellen Sie eine Erweiterung von UIViewController und dem aktuell aktiven TextField

//get active text field

Erweiterung UIViewController {func getSelectedTextField () -> UITextField? {

    let totalTextFields = getTextFieldsInView(view: self.view)

    for textField in totalTextFields{
        if textField.isFirstResponder{
            return textField
        }
    }

    return nil

}

func getTextFieldsInView(view: UIView) -> [UITextField] {

    var totalTextFields = [UITextField]()

    for subview in view.subviews as [UIView] {
        if let textField = subview as? UITextField {
            totalTextFields += [textField]
        } else {
            totalTextFields += getTextFieldsInView(view: subview)
        }
    }

    return totalTextFields
}

}}

Mintu Borah
quelle
Aus irgendeinem Grund hatte ich ein Problem mit der Funktion "keyboardWillShow". Die Größe der Tastaturgröße wurde nach dem ersten Umschalten der Tastatur falsch angegeben (der erste Umschalter hat den richtigen Rahmen). Ich habe dies behoben, indem ich es in guard let userInfo = notification.userInfo geändert habe. NSValue else {return} let keyboardFrame = keyboardSize.cgRectValue if self.view.frame.origin.y == 0 {self.view.frame.origin.y - = getMoveableDistance (keyboarHeight: keyboardFrame.height)} wenn jemand das gleiche Problem hat :)
Youstanzr
1

Sehr einfach und keine Notwendigkeit, mehr zu codieren. pod 'IQKeyboardManagerSwift'Fügen Sie einfach Ihre Poddatei hinzu und fügen Sie auf Ihrer AppDelegateSeite den folgenden Code hinzu.

import IQKeyboardManagerSwift

und in didFinishLaunchingWithOptions()Verfahrenstyp

IQKeyboardManager.shared.enable = true

das ist es. Überprüfen Sie diesen Videolink, um https://youtu.be/eOM94K1ZWN8 besser zu verstehen. Ich hoffe, dies wird Ihnen helfen.

Raghib Arshi
quelle
Funktioniert es für TextView und wie kann ich den Titel für die Eingabetaste "Fertig" ändern?
tdt kien
Gehe zu: - "IQKeyboardManager.m" Ersetzen Sie diese Zeile (Zeile Nr. 968): - [textField addDoneOnKeyboardWithTarget: Selbstaktion: @selector (doneAction :) shouldShowPlaceholder: _shouldShowTextFieldPlaceholder] durch Folgendes: - [textField addRightButtonOnKeyboardith: Selbstaktion: @selector (doneAction :) shouldShowPlaceholder: _shouldShowTextFieldPlaceholder]; Und habe es noch nicht für die Textansicht versucht, hoffe das würde dir helfen.
Raghib Arshi
1

Vollständiger Code zur Verwaltung der Tastatur.

        override func viewWillAppear(_ animated: Bool) {
            NotificationCenter.default.addObserver(self, selector: #selector(StoryMediaVC.keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
            NotificationCenter.default.addObserver(self, selector: #selector(StoryMediaVC.keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)
        }
        override func viewWillDisappear(_ animated: Bool) {
            NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillShowNotification, object: nil)
            NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillHideNotification, object: nil)
        }
        @objc func keyboardWillShow(notification: NSNotification) {
            guard let userInfo = notification.userInfo else {return}
            guard let keyboardSize = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue else {return}
            let keyboardFrame = keyboardSize.cgRectValue

            if self.view.bounds.origin.y == 0{
                self.view.bounds.origin.y += keyboardFrame.height
            }
        }


        @objc func keyboardWillHide(notification: NSNotification) {
            if self.view.bounds.origin.y != 0 {
                self.view.bounds.origin.y = 0
            }
        }
Avijit Nagare
quelle
0

Ich habe die @ Simpa-Lösung ein wenig modifiziert .........

override func viewDidLoad() 
{

    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("makeSpaceForKeyboard:"), name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("makeSpaceForKeyboard:"), name:UIKeyboardWillHideNotification, object: nil);
}

deinit{
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

var keyboardIsVisible = false
override func makeSpaceForKeyboard(notification: NSNotification) {

    let info = notification.userInfo!
    let keyboardHeight:CGFloat = (info[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue().size.height
    let duration:Double = info[UIKeyboardAnimationDurationUserInfoKey] as! Double

    if notification.name == UIKeyboardWillShowNotification && keyboardIsVisible == false{

        keyboardIsVisible = true

        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height - keyboardHeight
            self.view.frame = frame
        })

    } else if keyboardIsVisible == true && notification.name == UIKeyboardWillShowNotification{

    }else {
        keyboardIsVisible = false

        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height + keyboardHeight
            self.view.frame = frame
        })
    }
}
Cloy
quelle
0

Keiner von ihnen hat funktioniert, und ich habe schließlich Inhaltseinfügungen verwendet, um meine Ansicht nach oben zu verschieben, wenn die Tastatur angezeigt wird.

Hinweis: Ich habe eine UITableView verwendet

Referenzierte Lösung @ Keyboard-Content-Offset die vollständig in Ziel C geschrieben wurde. Die folgende Lösung ist Clean Swift.

Fügen Sie den Benachrichtigungsbeobachter @ viewDidLoad () hinzu.

NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(yourClass.keyboardWillBeShown), name:UIKeyboardWillShowNotification, object: nil);
NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(yourClass.keyboardWillBeHidden), name:UIKeyboardWillHideNotification, object: nil);

Um die Tastaturgröße zu ermitteln, rufen wir zuerst das userInfo-Wörterbuch aus dem Benachrichtigungsobjekt ab, in dem alle zusätzlichen Objekte gespeichert sind, die unser Empfänger möglicherweise verwendet.

Aus diesem Wörterbuch können wir das CGRect-Objekt erhalten, das den Rahmen der Tastatur beschreibt, indem wir die Taste UIKeyboardFrameBeginUserInfoKey verwenden.

Wenden Sie den Inhaltseinsatz für die Methode table view @ keyboardWillBeShown an.

func keyboardWillBeShown(sender: NSNotification)
{        
    // Move the table view

    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()
    {
        let contentInsets = UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.height), 0.0);

        yourTableView.contentInset = contentInsets;

        yourTableView.scrollIndicatorInsets = contentInsets;
    }
}

Stellen Sie die Methode view @ keyboardWillBeHidden wieder her

func keyboardWillBeHidden(sender: NSNotification)
{
    // Moving back the table view back to the default position

    yourTableView.contentInset = UIEdgeInsetsZero;

    yourTableView.scrollIndicatorInsets = UIEdgeInsetsZero;
}

Wenn Sie auch die Geräteorientierung berücksichtigen möchten, verwenden Sie bedingte Anweisungen, um den Code an Ihre Anforderungen anzupassen.

// Portrait
UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.height), 0.0);

// Landscape
UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.width), 0.0);
Vikram Ezhil
quelle
0
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
}

func keyboardWillShow(_ notification:Notification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        tableView.contentInset = UIEdgeInsetsMake(0, 0, keyboardSize.height, 0)
    }
}

func keyboardWillHide(_ notification:Notification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        tableView.contentInset = UIEdgeInsetsMake(0, 0, 0, 0)
    }
}

Geben Sie hier die Bildbeschreibung ein

Zany
quelle
0

Die Swift 4-Lösung, die ich verwende, nimmt die Tastaturgröße an. Ersetzen Sie serverStatusStackViewmit dem, was sehen Sie kümmern uns um, zum Beispiel: self.view:

deinit {
    NotificationCenter.default.removeObserver(self)
}

@objc func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        serverStatusStackView.frame.origin.y = keyboardSize.height * 2 - serverStatusStackView.frame.height
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        serverStatusStackView.frame.origin.y += keyboardSize.height
    }
}

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow(notification:)), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide(notification:)), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
}
BEIM
quelle