shouldChangeText not called for UITextField when using hardware keyboard - ios

Question

I have a sub class of UITextField and I want the sub class to control which input values are valid. That I have solved by overriding the shouldChangeText(in:, replacementText:) -> Bool method in the sub class. But this is only called when using the on-screen keyboard. If I use a hardware keyboard it doesn't get called.
The textField(_ textField:, shouldChangeCharactersIn:, replacementString:) -> Bool is called on the UITextFieldDelegate, when using a hardware keyboard. But I do not want to assign the delegate to the text field itself, since I need the delegate in some view controllers for other purposes. So I need an alternative method to validate the input values, like the shouldChangeText(in:, replacementText:) -> Bool gives me for the on-screen keyboard.
I can see on the stack trace from the delegate method, that the system has called a [UITextField keyboardInput:shouldInsertText:isMarkedText:], but I can't override that.
Is there any way to solve this, without assigning the delegate?

Answer 1

Here's an alternate solution that allows both your "real" text field delegate and your custom text field class to implement one more delegate methods.
The code below allows this custom text field to implement any of the needed UITextField delegate methods while still allowing the real delegate to implement any that it needs. The only requirement is that for any delegate method implemented inside the custom text field, you must check to see if the real delegate also implements it and call it as needed. Any delegate methods implemented in the real delegate class should be written normally.
This simple custom text field example is setup to only allow numbers. But it leaves the real delegate of the text field to do other validations such as only allowing a certain length of numbers or a specific range or whatever.
import UIKit
class MyTextField: UITextField, UITextFieldDelegate {
private var realDelegate: UITextFieldDelegate?
// Keep track of the text field's real delegate
override var delegate: UITextFieldDelegate? {
get {
return realDelegate
}
set {
realDelegate = newValue
}
}
override init(frame: CGRect) {
super.init(frame: frame)
// Make the text field its own delegate
super.delegate = self
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
// Make the text field its own delegate
super.delegate = self
}
// This is one third of the magic
override func forwardingTarget(for aSelector: Selector!) -> Any? {
if let realDelegate = realDelegate, realDelegate.responds(to: aSelector) {
return realDelegate
} else {
return super.forwardingTarget(for: aSelector)
}
}
// This is another third of the magic
override func responds(to aSelector: Selector!) -> Bool {
if let realDelegate = realDelegate, realDelegate.responds(to: aSelector) {
return true
} else {
return super.responds(to: aSelector)
}
}
// And the last third
// This only allows numbers to be typed into the text field.
// Of course this can be changed to do whatever validation you need in this custom text field
func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
if string.rangeOfCharacter(from: CharacterSet.decimalDigits.inverted) != nil {
return false // Not a number - fail
} else {
// The string is valid, now let the real delegate decide
if let delegate = realDelegate, delegate.responds(to: #selector(textField(_:shouldChangeCharactersIn:replacementString:))) {
return delegate.textField!(textField, shouldChangeCharactersIn: range, replacementString: string)
} else {
return true
}
}
}
}
The only other complication I leave as an exercise is a case where the custom text field wants to modify the changing text and then allow the real delegate to determine if that modified string/range should be allowed.