키보드가 빠르게 나타날 때 텍스트 필드 이동


217

iOS 프로그래밍에 Swift를 사용하고 있으며이 코드를 사용하여를 이동 UITextField하지만 작동하지 않습니다. 함수를 keyboardWillShow올바르게 호출 했지만 텍스트 필드가 이동하지 않습니다. 자동 레이아웃을 사용하고 있습니다.

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")
    }
}

2
프로젝트와 연습 가이드 파일 : codebeaulieu.com/43/...
댄 보리

아마도 deinit와 viewDidLoad는 균형이 맞지 않습니다.
Ricardo

Apple의 문서와 개인적인 경험을 바탕으로합니다. github.com/29satnam/MoveTextFieldWhenKeyboardAppearsSwift
Codetard

답변:


315

기존 답변에서 몇 가지 개선 사항이 있습니다.

우선 UIKeyboardWillChangeFrameNotification 은 표시 / 숨기기뿐만 아니라 키보드 변경 (언어, 타사 키보드 사용 등) 및 회전으로 인한 변경 사항도 처리하므로 키보드를 숨길 것입니다. 하드웨어 키보드 연결을 지원하도록 처리됩니다).

둘째, 애니메이션에서 매개 변수를 가져와 애니메이션이 올바르게 결합되도록 할 수 있습니다.

사전 코드를 강제로 풀어 놓는 것이 편한 경우이 코드를 좀 더 정리할 수있는 옵션이있을 수 있습니다.

스위프트 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)
    }
}

(아래 @Gabox의 멋진 의견에 따라 축소 대신 화면을 애니메이션으로 표시하는 키보드를 설명하도록 편집)

스위프트 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)
    }
}

1
@JosephLord 좋아요. 그러나 키보드가 숨겨져 있지 않을 때 이것이 작동하지 않는다는 것을 알았습니다 endFrame?.size.height. 끝 프레임을로 받았습니다 UIKeyboardFrameEndUserInfoKey = "NSRect: {{0, 1024}, {768, 264}}";. iOS 8.3 iPad Simulator, Portrait에서 실행되었습니다. Xcode6.3 베타 4.
Hlung

8
키보드가 숨겨지지 않으면 endFrame? .origin.y> = UIScreen.mainScreen (). bounds.size.height {self.keyboardHeightLayoutConstraint? .constant = 0.0} else {self.keyboardHeightLayoutConstraint? .constant 인 경우이 코드를 사용해보십시오. = endFrame.size.height}
가브리엘 Goncalves은

3
keyBoardHeightLayoutConstraint는 뷰 컨트롤러의 하단 레이아웃 가이드 또는 기본 뷰의 하단으로 이동 / 축소하려는 뷰의 하단을 제한하는 InterfaceBuilder에 정의 된 구속 조건입니다. 상수는 처음에 0으로 설정되며 키보드가 나타나거나 크기가 변경 될 때 키보드를위한 공간을 만들기 위해 조정됩니다.
Joseph Lord

2
참고 .UIKeyboardWillChangeFrame하드웨어 키보드가 아이폰 OS 키보드가 사라하더라도 연결되어있을 때 발생하지 않습니다. .UIKeyboardWillHide그 우연한 사례를 포착하기 위해 관찰해야합니다 .
jamesk 2012

1
@Sulthan은 정상적으로 작동합니다. 내 문제는 keybaord보다 약간 높아지고 있다는 것입니다. 이 문제를 해결할 수있는 방법이 있습니까?
Pavlos

128

자동 레이아웃을 사용하는 경우 Bottom Space를 Superview 제약 조건으로 설정했다고 가정합니다 . 이 경우 제약 조건의 값을 업데이트하기 만하면됩니다. 다음은 약간의 애니메이션으로 수행하는 방법입니다.

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
    })
}

하드 코딩 된 20은 키보드 위의 텍스트 필드를 약간만 띄우기 위해 추가됩니다. 그렇지 않으면 키보드의 상단 여백과 텍스트 필드의 하단 여백이 닿을 것입니다.

키보드가 해제되면 구속 조건 값을 원래 값으로 재설정하십시오.


1
내가 어떻게 그것을 정의하는지 pls를 설명해 주시겠습니까? 감사! 난 항상 스토리 보드에서 모든 것을 제어합니다
Pedro Manfredi

4
bottomConstraint는 구속 조건에 부여한 이름입니다. 나는 constrant를 선택하고 드래그하여 IBOutlet을 생성하고 그 이름을 지정했습니다. 버튼 및 텍스트 필드와 같은 다른 UI 요소와 마찬가지로 IBOutlet을 구속 조건으로 작성할 수 있습니다.
Isuru

2
이 답변은 애니메이션이 즉시 나에게 일어난 것을 제외하고는 훌륭하게 작동했습니다. 확인 I에게 애니메이션 제약 조건 변경을 할 수 있습니까? 제대로 애니메이션하는 방법.
Adam Johns

2
@ vinbhai4u UIKeyboardWillShowNotification알림 을 받으려면 등록해야합니다 . OP의 질문에있는 코드를보십시오.
Isuru

8
@AdamJohns 제약 조건 변경에 애니메이션을 적용하려면 외부의 상수를 업데이트 하고 애니메이션 블록 내부를 animateWithDuration호출 self.view.layoutIfNeeded()하십시오.
최대

110

간단한 해결책은 일정한 키보드 높이로 뷰를 위로 올리는 것입니다.

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  
}

스위프트 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);

4
나는이 간단한 해결책을 좋아한다. 그러나 하나 이상의 텍스트 필드로 이동했기 때문에 키보드를 표시하는 부울을 추가했습니다. 키보드가 표시되는 동안 키보드를 한 번만 움직입니다. 감사.
Ken

2
보기를 이동하는 대신 textView를 이동하십시오.
ericgu

1
사용자가 입력 언어를 전환하면 뷰의 y 값을 뺀 값을 유지합니다.
Jeffrey Neo

self.view를 변경하는 대신 self.myConstraint 값을 수행했지만 작동하지만 제약 조건이 적용되는 뷰는 계속 올라갑니다. 누구 든지이 문제에 직면 했습니까?
Sashi

5
사용하는 대신 self.view.frame.origin.y -= 150사용 self.view.frame.origin.y = -150하고 대신에 self.view.frame.origin.y += 150사용 self.view.frame.origin.y = 0. 이것은 새로운 필드가 터치 될 때마다 뷰가 이동하는 것을 방지한다.
gunwin

43

텍스트 필드를 편집하는 동안보기를 이동하려면 이것을 시도하십시오.

옵션 1 :-** ** NotificationCenter를 사용하여 Swift 5.0 및 iPhone X, XR, XS 및 XS Max Move 에서 업데이트

  • 이 알림을 등록하십시오 func viewWillAppear(_ animated: Bool)

  • 이 알림을 등록 취소 func viewWillDisappear(_ animated: Bool)

참고 :-등록을 취소하지 않으면 하위 클래스에서 전화하는 것보다 충돌이 발생하거나 다른 이유가 있습니다.

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)
    }
}

옵션 2 :- 잘 작동합니다

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()
}

키보드에서 Swift에 나타날 때이 소스 UITextField 위로 이동 하여이 답변을 얻었 습니다.

스위프트 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()
    }

1
@ Jogendra.Com, 노력해 주셔서 감사합니다.하지만 iPhone 5, 4s 및 6에서 가장 잘 작동합니다. 그러나 iPhone 6plus 및 iPad에서 더 높은 기능을 사용하지 않도록 설정하려면 어떻게해야합니까
Thiha Aung

옵션 1을 사용하는 경우 제한 조건 IBOutlet을 추가하십시오. 자동 레이아웃을 사용하여 크기를 조정하려는 제약 조건을 만든 다음 뷰 컨트롤러로 드래그 앤 드롭하여 애니메이션 함수에서 self.iboutletConstraint.constant로 참조하는 IBOutlet을 만듭니다. 또한 키보드를 숨길 때 콘센트를 다시 조정하지는 않지만 제약 조건을 원래 값으로 재설정하여 처리했습니다.
Hammad Tariq

21

나는 깨끗한 스위프트 코드를 좋아한다. 키보드로 텍스트보기를 위 / 아래로 이동하기 위해 올릴 수있는 가장 엄격한 코드가 있습니다. 현재 iOS8 / 9 Swift 2 프로덕션 앱에서 작동하고 있습니다.

업데이트 (2016 년 3 월) : 방금 이전 코드를 최대한 강화했습니다. 또한 키보드 높이와 애니메이션 매개 변수를 하드 코딩하는 인기있는 답변이 많이 있습니다. 이 답변의 숫자가 6s + iOS9 (키보드 높이 226, 지속 시간 0.25 및 애니메이션 곡선 7)에서 내가보고있는 실제 값과 항상 일치하는 것은 아닙니다. 어쨌든 시스템에서 해당 값을 가져 오는 추가 코드는 거의 없습니다. 아래를 참조하십시오.

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
    )

}

참고 :이 코드는 대부분의 주석 / 일반 사례를 다룹니다. 그러나 다른 방향 및 / 또는 사용자 정의 키보드를 처리하기 위해 더 많은 코드가 필요할 수 있습니다 . iOS 키보드 작업에 대한 자세한 내용다음과 같습니다 . 모든 시나리오를 처리해야 할 경우 도움이 될 수 있습니다.


Swift 1.1 인 것 같으며 Swift 1.2에서는 as강제 캐스트에 사용 하기 때문에 컴파일되지 않을 것이라고 생각 합니다. as!작동하지만이 페이지의 다른 곳에서 볼 수 있듯이 강제 캐스트를 피하고 나 자신을 풀 수 있습니다.
Joseph Lord

Swift 1.2에서 컴파일 그리고 코드에 주석을 추가했습니다 : 강제 언 래핑. 건배.
scootermg 2014 년

죄송합니다. 나는 스위프트 2를 의미했다.
scootermg

연결 방법에 따라 대신 연결 baseConstraint되었을 수 있습니다 . baseConstraint.constant = moveUp ? keyboardHeight : 0baseConstraint.constant = moveUp ? -keyboardHeight : 0
limfinity

15

편집 : 더 쉽고 깨끗한 솔루션을 추천합니다. 하단 간격 제약 조건의 클래스를 KeyboardLayoutConstraint로 변경하십시오 . 키보드 높이까지 자동으로 확장됩니다.


이것은 @JosephLord 답변의 향상된 버전입니다.

iOS 8.3 iPad Simulator, Portrait에서 테스트되었습니다. Xcode6.3 beta4, 나는 때문에 키보드가 숨어있을 때 그의 대답은 작동하지 않습니다 발견 UIKeyboardFrameEndUserInfoKey이다 "NSRect: {{0, 1024}, {768, 264}}";. 높이는 결코 없습니다 0.

이 전통을 사용하는 거슬러 올라갑니다 UIKeyboardWillShowNotificationUIKeyboardWillHideNotification키보드가 최종 프레임의 높이에 의존하기보다는 숨기는 경우 더 말할. UIKeyboardWillShowNotification키보드 프레임이 변경 될 때도 전송되므로 모든 사용 사례를 포괄해야합니다.

    // 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)
        }
    }

편집 내용을 설명해 주시겠습니까? 나는 그것을 작동시킬 수 없었다. 하단에 버튼이있는 UIScrollView가 있습니다. 나는 클래스를 하단의 마진 하단 제약 조건으로 설정했습니다.
schw4ndi

@ schw4ndi 귀하의 하단 제약 조건은 어떤 견해와 관련이 있습니까? scrollview의 맨 아래를 해당 scrollview의 superview 맨 아래에 연결해야합니다.
Hlung

오, 고마워, 나는 버튼과 scrollView 사이에 제약이 있었다
schw4ndi

9

나는 신속한 4로 작업하고 있으며 코드가 여기에있는 여분의 하단 제약 조건을 사용하지 않고이 문제를 해결했습니다.

1)로드 된 알림 관찰자 추가

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) 다음과 같은 알림 관찰자를 제거하십시오.

deinit {
        NotificationCenter.default.removeObserver(self)
    }

3) 키보드 표시 / 숨기기 방법 추가

 @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) textfeild 델리게이트 추가 및 touchesBegan 메소드 추가 화면에서 textfeild 외부를 터치 할 때 키보드를 숨기는 데 유용합니다.

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

    }

할 필요가UIKeyboardFrameEndUserInfoKey
마이크로

1
NSNotification.Name.UIKeyboardWillShow 이름이 바뀝니다 UIResponder.keyboardWillShowNotificationUIKeyboardFrameBeginUserInfoKey UIResponder.keyboardFrameBeginUserInfoKey
SMJ

7

이것은 @JosephLord와 @Hlung의 답변의 개선 된 버전입니다. 탭 바가 있는지 여부를 적용 할 수 있습니다. 그리고 키보드로 원래 위치로 이동 한 뷰를 완벽하게 복원합니다.

// 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)
        }
}

6

코드가 필요없는 가장 쉬운 방법 :

  1. KeyboardLayoutConstraint.swift 다운로드Spring 애니메이션 프레임 워크를 아직 사용하지 않는 경우 하고 파일을 프로젝트에 추가 (끌어다 놓기)하십시오.
  2. 스토리 보드에서 객체 /보기 / 텍스트 필드의 맨 아래 제약 조건을 만들고 제약 조건을 두 번 클릭 한 다음 Identity Inspector에서 클래스를 NSLayoutConstraint에서 KeyboardLayoutConstraint로 변경하십시오.
  3. 끝난!

객체는 키보드와 함께 자동으로 위로 움직입니다.


2
훌륭한 솔루션! 그러나 안전 영역이 필요합니다. 제약 조건의 첫 번째 항목으로 아래가 두 번째 항목 일 때 작동하지 않았습니다. 또한 필드와 키보드를 표시하기에 충분히 멀리 움직이지 않고 상수를 유지하고 조정하므로 상수를 0으로 설정하면 가장 효과적입니다.
Mythlandia

KeyboardLayoutConstraint swift4 버전이 있습니까?
jeet.chanchawat

6

키보드 모양 / 사라짐을 처리하기 위해 Swift 3 프로토콜을 만들었습니다.

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)
  }

}

그런 다음 UIViewController에서 구현하려면 다음을 수행하십시오.

  • viewController가이 프로토콜을 따르도록하십시오 :

    class FormMailVC: UIViewControlle, KeyboardHandler {
  • viewWillAppear에서 키보드 변경 사항을 관찰하십시오.

    // MARK: - View controller life cycle
    override func viewWillAppear(_ animated: Bool) {
      super.viewWillAppear(animated)
      startObservingKeyboardChanges()
    }
  • view에서 키보드 변경 사항 관찰을 중지하십시오.

    override func viewWillDisappear(_ animated: Bool) {
      super.viewWillDisappear(animated)
      stopObservingKeyboardChanges()
    }
  • 스토리 보드에서 하단 제약 조건에 대한 IBOutlet을 만듭니다.

    // NSLayoutConstraints
    @IBOutlet weak var bottomConstraint: NSLayoutConstraint!

    (모든 UI를 "contentView"에 포함시키고이 contentView의 하단 제한 조건을이 contentView에서 하단 레이아웃 안내서로 링크하는 것이 좋습니다.) 컨텐츠 뷰 하단 제약

  • 상단 구속 조건 의 구속 조건 우선 순위 를 250 (낮음)으로 변경

콘텐츠 뷰 상단 제약

이는 키보드가 나타날 때 전체 컨텐츠보기를 위쪽으로 슬라이드하도록하기위한 것입니다. 우선 순위는 컨텐츠 포옹 우선 순위 / 컨텐츠 압축 저항 우선 순위를 포함하여 서브 뷰의 다른 제한 우선 순위보다 낮아야합니다.

  • Autolayout에 contentView의 슬라이드 방식을 결정하기에 충분한 제약 조건이 있는지 확인하십시오.

이를 위해 "동일보다 큰"제한 조건을 추가해야 할 수도 있습니다. "동일보다 큰"제약

그리고 여기 있습니다! 키보드없이

키보드로


경고없이 "관계 = 동일"도 넣으면 효과가 있습니다.
Valtoni Boaventura

동등한 관계를 설정하면 특정 상황에서만 작동 할 수 있습니다. 다른 경우 자동 레이아웃 불일치 경고가 표시 될 수 있습니다. 자신의 레이아웃에 따라 다릅니다. 그래서 내가 "당신이해야 할지도 모른다"고 말한 것입니다.
Frédéric Adda

프레데릭은 동의했다. 좋은 해결책이었습니다!
Valtoni Boaventura

누락import UIKit
Mirko

6

이러한 간단한 UIViewController 확장을 사용할 수 있습니다

//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)
    }
}

사용 예

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()
    })
}

스위프트 4 솔루션

//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)
  }
}

스위프트 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")
                                                }
        })
    }
}

2
:) 여기 확실히 최고의 하나> - 훨씬 더 "스위프트는"다른 솔루션에 비해 / 모두를 다시 작성하지 않고도 모든 컨트롤러에 큰 / 재사용을 작동
TIB

UIScrollView가 필요합니까 아니면 무엇을 시도 했습니까?
erdemgc

@erdemgc 사용 예를 보셨습니까? UIViewControlller + addKeyboardChangeFrameObserver 만 있으면 제거 할 수 있습니다.
ale_stro

여기서 removeKeyboardObserver()방법은 실제로 관찰자를 제거하지 않습니다. 이것을 호출하지 않으면 Invalid conditions for UIKeyboardWillChangeFrameNotification콘솔에 add 메소드의가 표시됩니다. 이것을 호출하면 동일한 오류가 표시되어 관찰자가 제거되지 않습니다. 문서에는 "관찰을 등록 취소하려면이 방법으로 반환 된 개체를에 전달합니다 removeObserver(_:)."라고 나와 있습니다. 따라서 대신에 메소드가 반환 한 객체를 저장 한 다음 관찰자를 제거 할 때 전달합니다.
Huy-Anh Hoang

실제로 스크롤보기가로드되면 bound에 값이 할당되고 키보드 프레임이 bound와 교차하면 키보드가 숨겨 지는지를 감지 할 수 없습니다.
James Kim

5

이 라이브러리를 사용할 수 있으며 appDidFinishedLaunching에 단 한 줄의 코드 만 있으면됩니다.

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

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

- IQKeyboardManager은 - 키보드가 링크를 표시 할 때마다보기를 조정 https://github.com/hackiftekhar/IQKeyboardManager을


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()

}

마지막으로 델리게이트 메소드를 사용하기 때문에

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

objective-c 사용을 리팩토링했습니다 http://www.cocoawithlove.com/2008/10/sliding-uitextfields-around-to-avoid.html


이 솔루션은 추가 작업을 수행해야했지만 나에게 도움이되었습니다. var animateDistance: CGFloat!플러스 선언 은 사용자가 키보드 숨기기 버튼을 누를 때 UIKeyboardWillHideNotification을 처리해야했습니다.
Rhuantavan

4

자동 레이아웃, 제약 조건 또는 콘센트에 의존하지 않는 다른 솔루션. 필요한 것은 스크롤보기의 필드입니다.

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
        })
    }

}

1
UIKeyboardWillShowNotification호출 후 검은 화면이 표시 됩니다.
Sachin Kumaram

4

Swift 2.2 솔루션에 대한 내 버전은 다음과 같습니다.

키보드 표시 / 숨기기 알림에 대한 첫 등록

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

그런 다음 해당 알림에 대한 코어 응답 방법에서 기본보기를 위 또는 아래로 이동

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
}

요령은 "QuickType Suggestion Bar"가 확장되거나 축소 될 때마다 호출되는 "keyboardWillShow"부분에 있습니다. 그런 다음 항상 메인 뷰의 y 좌표를 총 키보드 높이의 음수 값과 동일하게 설정합니다 ( "QuickType 막대"부분 유무).

결국 관찰자를 제거하는 것을 잊지 마십시오

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

3

다음은 간단한 해결책으로, 텍스트 필드에는 하단 레이아웃 안내서와 연결되는 제약이 있습니다. 키보드 높이를 구속 조건 상수에 추가하기 만하면됩니다.

// 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
    }
}

3

글쎄, 나는 너무 늦을지도 모르지만 Saqib의 대답에 대한 또 다른 간단한 버전을 발견했습니다. 제약 조건과 함께 자동 레이아웃을 사용하고 있습니다. 사용자 이름과 비밀번호 필드가있는 다른 기본보기 안에 작은보기가 있습니다. 뷰의 y 좌표를 변경하는 대신 원래 제약 조건 값을 변수에 저장하고 제약 조건 상수를 일부 값으로 변경하고 키보드가 종료 된 후에 다시 제약 조건을 원래 값으로 설정하고 있습니다. 이런 식으로 Saqib의 답변이 갖는 문제를 피할 수 있습니다 (보기는 계속 진행되며 멈추지 않습니다). 아래는 내 코드입니다 ...

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
  }

내부 keyboardWillShow의 상태에 대한 검사 방법 self.centerYConstraint.constant == self.originalCenterYConstraint이 경우 다음이 상태 사이에서 코드의 하나 개의 라인을 가지고있다. OriginalCenterYContraint는 viewdidload에 저장하는 centerYContraint의 원래 값입니다. 이것은 나를 위해 일했습니다.
사시

3

@Joseph Lord와 @Isuru의 답변을 병합하여 Swift 4.x 답변. bottomConstraint이동하려는 뷰의 하단 제약 조건을 나타냅니다.

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)
    }
}

2

나는 다음과 같은 방식으로 수행했다.

텍스트 필드 슈퍼 뷰가 표시 될 때 유용합니다

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
    }
    } }

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

    }

1
위의 코드를 사용하여 텍스트 필드를 키보드 위의 빠른 2.2로 이동하면 잘 작동합니다. 나는 그것이 도움이되기를 바랍니다.
Kamalkumar. E

1

나는 다음과 같이했다 :

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

1

위의 모든 해결책을 시도해 보았지만 여전히 문제가 해결되지 않은 나와 같은 경우 매력처럼 작동하는 훌륭한 해결책이 있습니다. 먼저 위에서 언급 한 솔루션 중 몇 가지에 대해 명확하게 설명하고 싶습니다.

  1. 필자의 경우 IQkeyboardmanager는 요소에 자동 레이아웃이 적용되지 않은 경우에만 작동하고 적용된 경우 IQkeyboard Manager는 우리가 생각하는 방식으로 작동하지 않습니다.
  2. self.view의 상향 이동과 같은 것 .
  3. 사용자가 클릭 할 때 UITexfield를 위로 밀어 올리는 신속한 지원으로 객관적인 c 헤더를 작성하여 UITextfield를 덮는 키보드 문제를 해결했습니다 : https://github.com/coolvasanth/smart_keyboard .
  4. iOS 앱 개발에서 중간 이상의 레벨을 가진 사람은 저장소를 쉽게 이해하고 구현할 수 있습니다. 모두 제일 좋다

1

다음은 모든 TextField 단계에 대한 일반적인 솔루션입니다.

1) 다른 ViewController로 확장 된 공통 ViewController를 만듭니다.

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) UIViewController와 현재 활성화 된 TextField의 확장을 만듭니다

//get active text field

확장 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
}

}


어떤 이유로 든 keyboardWillShow 기능에 문제가 있었는데, 첫 번째 키보드 전환 후 첫 번째 키보드 전환 후 올바른 키보드 크기가 잘못되었습니다. 이것을 user user = notification.userInfo else {return} guard let keyboardSize = userInfo [UIResponder.keyboardFrameEndUserInfoKey] 가드로 변경하여 수정했습니다. NSValue else {return} let self.view.frame.origin.y == 0 {self.view.frame.origin.y-= getMoveableDistance (keyboarHeight : keyboardFrame.height)}. 희망이 있으면 도움이 될 것입니다 keyboardFrame = keyboardSize.cgRectValue 누군가 같은 문제가 발생하면 :)
Youstanzr

1

매우 간단하고 더 코딩 할 필요가 없습니다. pod 'IQKeyboardManagerSwift'podfile에 추가 하고 AppDelegate페이지에 아래 코드를 추가하십시오.

import IQKeyboardManagerSwift

메소드 didFinishLaunchingWithOptions()유형

IQKeyboardManager.shared.enable = true

그게 다야. https://youtu.be/eOM94K1ZWN8 이해를 돕기 위해이 비디오 링크를 확인하십시오. 이것이 도움이되기를 바랍니다 .


TextView에서 작동하며 리턴 키 "완료"의 제목을 어떻게 변경할 수 있습니까?
tdt kien

Goto :- "IQKeyboardManager.m"이 줄을 바꾸십시오 (줄 번호 968) :-[textField addDoneOnKeyboardWithTarget : self action : @selector (doneAction :) shouldShowPlaceholder : _shouldShowTextFieldPlaceholder] with this :-[textField addRightButtonOnKeyboardWithText : @ "YOURTEXT"대상 : 자체 조치 : @selector (doneAction :) shouldShowPlaceholder : _shouldShowTextFieldPlaceholder]; 그리고 텍스트 뷰를 아직 시도하지 않았으므로 이것이 도움이되기를 바랍니다.
Raghib Arshi

1

키보드 관리를위한 완전한 코드.

        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
            }
        }

0

@Simpa 솔루션을 약간 수정했습니다 .........

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
        })
    }
}

0

그들 중 어느 것도 효과가 없었으며 키보드가 나타날 때 컨텐츠 삽입을 사용하여 뷰를 위로 움직였습니다.

노트 : UITableView를 사용하고있었습니다

참조 된 솔루션 @ 키보드 컨텐츠 오프셋객관적 C로 완전히 작성된 , 아래 솔루션은 깨끗한 Swift입니다.

알림 관찰자를 추가하십시오 @ viewDidLoad ()

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

키보드 크기를 얻으려면 먼저 수신자 객체가 사용할 수있는 추가 객체를 저장하는 알림 객체에서 userInfo 사전을 가져옵니다.

사전에서 UIKeyboardFrameBeginUserInfoKey 키를 사용하여 키보드 프레임을 설명하는 CGRect 객체를 얻을 수 있습니다.

표보기 @ keyboardWillBeShown 메소드에 컨텐츠 삽입을 적용하십시오.

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;
    }
}

@ keyboardWillBeHidden 메소드를 복원하십시오.

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

    yourTableView.contentInset = UIEdgeInsetsZero;

    yourTableView.scrollIndicatorInsets = UIEdgeInsetsZero;
}

장치 방향도 고려하려면 조건문을 사용하여 필요에 따라 코드를 조정하십시오.

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

// Landscape
UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.width), 0.0);

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)
    }
}

여기에 이미지 설명을 입력하십시오


0

내가 사용하는 Swift 4 솔루션은 키보드 크기를 사용합니다. 대체 serverStatusStackView당신은, 예를 들어 신경 볼 뭐든 : 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)
}

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.