it-swarm.com.de

Wie kann ich programmgesteuert überprüfen, ob eine Tastatur in der iOS-App vorhanden ist?

Ich muss die Sichtbarkeit der Tastatur in meiner iOS-App überprüfen.

Pseudocode:

if(keyboardIsPresentOnWindow) {
    //Do action 1
}
else if (keyboardIsNotPresentOnWindow) {
    //Do action 2
}

Wie kann ich diesen Zustand überprüfen?

101
Jitendra Singh

… Oder nehmen Sie den einfachen Weg:

Wenn Sie ein Textfeld eingeben, wird es zu First Responder und die Tastatur wird angezeigt. Sie können den Status der Tastatur mit [myTextField isFirstResponder] überprüfen. Wenn YES zurückgegeben wird, ist die Tastatur aktiv. 

63
thpitsch

der Code von drawonward ist sehr ähnlich, kollidiert jedoch mit dem Namensraum von UIKit und könnte einfacher verwendet werden.

@interface KeyboardStateListener : NSObject {
    BOOL _isVisible;
}
+ (KeyboardStateListener *)sharedInstance;
@property (nonatomic, readonly, getter=isVisible) BOOL visible;
@end

static KeyboardStateListener *sharedInstance;

@implementation KeyboardStateListener

+ (KeyboardStateListener *)sharedInstance
{
    return sharedInstance;
}

+ (void)load
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    sharedInstance = [[self alloc] init];
    [pool release];
}

- (BOOL)isVisible
{
    return _isVisible;
}

- (void)didShow
{
    _isVisible = YES;
}

- (void)didHide
{
    _isVisible = NO;
}

- (id)init
{
    if ((self = [super init])) {
        NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
        [center addObserver:self selector:@selector(didShow) name:UIKeyboardDidShowNotification object:nil];
        [center addObserver:self selector:@selector(didHide) name:UIKeyboardWillHideNotification object:nil];
    }
    return self;
}

@end
62
rpetrich

Erstellen Sie eine UIKeyboardListener, wenn Sie wissen, dass die Tastatur nicht sichtbar ist, indem Sie beispielsweise [UIKeyboardListener shared] von applicationDidFinishLaunching aufrufen.

@implementation UIKeyboardListener

+ (UIKeyboardListener) shared {
    static UIKeyboardListener sListener;    
    if ( nil == sListener ) sListener = [[UIKeyboardListener alloc] init];

    return sListener;
}

-(id) init {
    self = [super init];

    if ( self ) {
        NSNotificationCenter        *center = [NSNotificationCenter defaultCenter];
        [center addObserver:self selector:@selector(noticeShowKeyboard:) name:UIKeyboardDidShowNotification object:nil];
        [center addObserver:self selector:@selector(noticeHideKeyboard:) name:UIKeyboardWillHideNotification object:nil];
    }

    return self;
}

-(void) noticeShowKeyboard:(NSNotification *)inNotification {
    _visible = true;
}

-(void) noticeHideKeyboard:(NSNotification *)inNotification {
    _visible = false;
}

-(BOOL) isVisible {
    return _visible;
}

@end
29
drawnonward

Ich denke, Sie müssen die Benachrichtigungen verwenden, die über die Tastatur bereitgestellt werden:

Von: http://developer.Apple.com/iphone/library/documentation/UIKit/Reference/UITextField_Class/Reference/UITextField.html

Tastaturbenachrichtigungen

Wenn das System die .__ anzeigt oder verbirgt. Tastatur, es gibt mehrere Tastaturen Benachrichtigungen. Diese Benachrichtigungen enthalten Informationen über die Tastatur, einschließlich ihrer Größe, die Sie können für Berechnungen das .__ verwenden. beinhalten bewegte Ansichten. Registrierung für Diese Benachrichtigungen sind der einzige Weg zu Einige Informationen über die Tastatur. Das System liefert das folgende Benachrichtigungen für Tastaturbezogene Ereignisse:

* UIKeyboardWillShowNotification
* UIKeyboardDidShowNotification
* UIKeyboardWillHideNotification
* UIKeyboardDidHideNotification

Weitere Informationen zu diesen Benachrichtigungen, siehe deren Beschreibungen in der UIWindow-Klassenreferenz. Zum Informationen zum Ein- und Ausblenden von die Tastatur finden Sie unter Text und Web.

29
beggs

Die Verwendung der Hierarchie der Unteransichten als Anzeige für die Tastaturanzeige ist ein Hack. Wenn Apple die zugrunde liegende Implementierung wechselt, würden all diese Antworten zerbrechen.

Die richtige Methode wäre, die Tastatur zu überwachen und Benachrichtigungen anwendungsweit anzuzeigen und auszublenden, beispielsweise in Ihrem App-Delegierten:

In AppDelegate.h:

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (assign, nonatomic) BOOL keyboardIsShowing;

@end

In AppDelegate.m:

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{

    // Monitor keyboard status application wide
    self.keyboardIsShowing = NO;
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillShow:)
                                             name:UIKeyboardWillShowNotification object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillBeHidden:)
                                             name:UIKeyboardWillHideNotification object:nil];

    return YES;
}

- (void)keyboardWillShow:(NSNotification*)aNotification
{
    self.keyboardIsShowing = YES;
}

- (void)keyboardWillBeHidden:(NSNotification*)aNotification
{
    self.keyboardIsShowing = NO;
}

Dann können Sie überprüfen mit:

BOOL keyboardIsShowing = ((AppDelegate*)[UIApplication sharedApplication].delegate).keyboardIsShowing;

Beachten Sie, dass die Benachrichtigungen zum Anzeigen/Ausblenden der Tastatur nicht ausgelöst werden, wenn der Benutzer eine Bluetooth-Tastatur oder eine externe Tastatur verwendet.

11
Vlad

Swift 3 Implementierung

    import Foundation
class KeyboardStateListener: NSObject
{
    static let shared = KeyboardStateListener()
    var isVisible = false

    func start() {
        NotificationCenter.default.addObserver(self, selector: #selector(didShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(didHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
    }

    func didShow()
    {
        isVisible = true
    }

    func didHide()
    {
        isVisible = false
    } 
}

Dies ist aus dem von Apple veröffentlichten iOS Text Programming Guide hier: https://developer.Apple.com/library/ios/documentation/StringsTextFonts/Conceptual/TextAndWebiPhoneOS/KeyboardManagement/KeyboardManagement.html

Rufen Sie grundsätzlich "registerForKeyBoardNotifications" in Ihrem ViewDidLoad auf. Jedes Mal, wenn die Tastatur aktiv wird, wird "keyboardWasShown" aufgerufen. Jedes Mal, wenn die Tastatur verschwindet, wird "keyboardWillBeHidden" aufgerufen.

// Call this method somewhere in your view controller setup code.
- (void)registerForKeyboardNotifications {
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWasShown:) name:UIKeyboardDidShowNotification object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillBeHidden:) name:UIKeyboardWillHideNotification object:nil];
}

// Called when the UIKeyboardDidShowNotification is sent.
- (void)keyboardWasShown:(NSNotification*)aNotification {
    NSLog(@"Keyboard is active.");
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;

    UIEdgeInsets contentInsets = UIEdgeInsetsMake(0.0, 0.0, kbSize.height, 0.0);
    scrollView.contentInset = contentInsets;
    scrollView.scrollIndicatorInsets = contentInsets;

    // If active text field is hidden by keyboard, scroll it so it's visible
    // Your app might not need or want this behavior.
    CGRect aRect = self.view.frame;
    aRect.size.height -= kbSize.height;
    if (!CGRectContainsPoint(aRect, activeField.frame.Origin) ) {
        [self.scrollView scrollRectToVisible:activeField.frame animated:YES];
    }
}

// Called when the UIKeyboardWillHideNotification is sent
- (void)keyboardWillBeHidden:(NSNotification*)aNotification {
    NSLog(@"Keyboard is hidden");
    UIEdgeInsets contentInsets = UIEdgeInsetsZero;
    scrollView.contentInset = contentInsets;
    scrollView.scrollIndicatorInsets = contentInsets;
}
5
Scuttle

In iOS8 funktioniert diese Lösung natürlich nicht .. __ Sie wurde ursprünglich für IOS4/5 geschrieben.

Versuchen Sie diese Lösung:

- (BOOL) isKeyboardOnScreen 
{
    BOOL isKeyboardShown = NO;

    NSArray *windows = [UIApplication sharedApplication].windows;
    if (windows.count > 1) {
        NSArray *wSubviews =  [windows[1]  subviews];
        if (wSubviews.count) {
            CGRect keyboardFrame = [wSubviews[0] frame];
            CGRect screenFrame = [windows[1] frame];
            if (keyboardFrame.Origin.y+keyboardFrame.size.height == screenFrame.size.height) {
                isKeyboardShown = YES;
            }
        }
    }

    return isKeyboardShown;
}
5
malex

Einige Bemerkungen: 

Das empfohlene Muster für ein Einzelobjekt wäre wie folgt. dispatch_once stellt sicher, dass die Klasse einmalig threadsicher initialisiert wird und die statische Variable außerhalb nicht sichtbar ist. Und es ist Standard-GCD, also müssen Sie nicht über die Details von Objective-C auf niedriger Ebene Bescheid wissen.

+ (KeyboardStateListener *)sharedInstance
{
    static KeyboardStateListener* shared;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        shared = [[KeyboardStateListener alloc] init];
        // Other initialisations
    });

    return shared;
}

Normalerweise möchten Sie nicht wissen, ob die Tastatur sichtbar ist oder nicht, sondern wie groß sie ist. Tastaturen haben nicht alle die gleiche Größe. iPhone-Tastaturen sind kleiner als iPad-Tastaturen. Sie möchten also eine andere Eigenschaft @property (readonly, nonatomic) CGRect keyboardRect;, die in der noticeShowKeyboard: -Methode wie folgt festgelegt wird:

NSValue* value = notification.userInfo [UIKeyboardFrameEndUserInfoKey];
_keyboardRect = value.CGRectValue;

Beachten Sie, dass sich das Rechteck in UIWindow-Koordinaten befindet und die Bildschirmdrehung nicht berücksichtigt wird. Der Aufrufer würde dieses Rechteck also durch Aufruf konvertieren

KeyboardStateListener* listener = [KeyboardStateListener sharedInstance];
CGRect windowRect = listener.keyboardRect;
CGRect viewRect = [myView convertRect:windowRect fromView:self.window];

Wenn der Benutzer den Bildschirm dreht, während die Tastatur sichtbar ist, wird der App mitgeteilt, dass die Tastatur ausgeblendet ist, und wird erneut angezeigt. Bei der Anzeige werden andere Ansichten höchstwahrscheinlich noch nicht gedreht. Wenn Sie also beobachten, dass Tastaturen Ereignisse anzeigen/ausblenden, konvertieren Sie die Koordinaten, wenn Sie sie wirklich brauchen, nicht in der Benachrichtigung. 

Wenn der Benutzer die Tastatur teilt oder entkoppelt oder eine Hardwaretastatur verwendet, wird die Tastatur in den Benachrichtigungen immer als ausgeblendet angezeigt. Beim Abdocken oder Zusammenführen der Tastatur wird eine Benachrichtigung über die angezeigte Tastatur gesendet. 

Der Listener muss initialisiert werden, während die Tastatur ausgeblendet ist. Andernfalls wird die erste Benachrichtigung versäumt. Es wird davon ausgegangen, dass die Tastatur ausgeblendet ist, wenn dies nicht der Fall ist. 

Es ist also wichtig zu wissen, was Sie eigentlich wollen. Dieser Code ist nützlich, um die Tastatur aus der Tastatur zu entfernen (bei einer geteilten oder abgedockten Tastatur liegt dies in der Verantwortung des Benutzers). Es sagt Ihnen nicht, ob der Benutzer eine Tastatur auf dem Bildschirm sehen kann (im Falle einer geteilten Tastatur). Es sagt Ihnen nicht, ob der Benutzer tippen kann (zum Beispiel, wenn eine Hardwaretastatur vorhanden ist). Der Blick auf andere Fenster funktioniert nicht, wenn die App andere Fenster selbst erstellt. 

4
Chris

Und so geht's in Swift: 

 func registerForKeyboardNotifications() {
    NSNotificationCenter.defaultCenter().addObserver(
        self,
        selector: "keyboardWasShown:",
        name: UIKeyboardDidShowNotification,
        object: nil)

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

func keyboardWasShown(notification: NSNotification) {
    println("Keyboard was shown");
}

func keyboardWillBeHidden(notification: NSNotification) {
    println("Keyboard was dismissed");
}

Vergessen Sie nicht, die Registrierung aufzuheben:

 override func viewWillDisappear(animated: Bool) {
    NSNotificationCenter.defaultCenter().removeObserver(self,
        name: UIKeyboardDidShowNotification,
        object: nil)

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

Und wenn Sie die Tastatur beim Drücken der "Return" -Taste schließen möchten

class ViewController: UIViewController, UITextFieldDelegate {

@IBOutlet weak var yourTextField: UITextField!

override func viewDidLoad() {
    super.viewDidLoad()
    registerForKeyboardNotifications()
    yourTextField.delegate = self
}

func textFieldShouldReturn(textField: UITextField!) -> Bool {
    self.view.endEditing(true);
    return false;
}

}
3
Teodor Ciuraru

Swift Implementierung:

class KeyboardStateListener: NSObject
{
  static var shared = KeyboardStateListener()
  var isVisible = false

  func start() {
    let nc = NSNotificationCenter.defaultCenter()
    nc.addObserver(self, selector: #selector(didShow), name: UIKeyboardDidShowNotification, object: nil)
    nc.addObserver(self, selector: #selector(didHide), name: UIKeyboardDidHideNotification, object: nil)
  }

  func didShow()
  {
    isVisible = true
  }

  func didHide()
  {
    isVisible = false
  } 
}

Da Swift die Klasse load -Methode beim Start nicht ausführt, ist es wichtig, diesen Dienst beim Start der App zu starten:

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool
{
  ...    
  KeyboardStateListener.shared.start() 
}
2
Prcela

BOOL isTxtOpen = [txtfieldObjct isFirstReponder]. Wenn JA zurückgegeben wird, ist die Tastatur aktiv.

1
Hardik Mamtora

Dies ist meine Lösung, sie kapselt alles in einer einzigen statischen Methode ein, und Sie können sie überall aufrufen, um Folgendes zu überprüfen:

+(BOOL)isKeyboardVisible{
    static id tokenKeyboardWillShow = nil;
    static id tokenKeyboardWillHide = nil;
    static BOOL isKbVisible = NO;
    @synchronized (self) {
        if (tokenKeyboardWillShow == nil){
            tokenKeyboardWillShow = [[NSNotificationCenter defaultCenter] addObserverForName:UIKeyboardWillShowNotification object:nil queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification * _Nonnull note) {
                @synchronized (self) {
                    isKbVisible = YES;
                }
            }];
        }

        if (tokenKeyboardWillHide == nil){
            tokenKeyboardWillHide = [[NSNotificationCenter defaultCenter] addObserverForName:UIKeyboardWillHideNotification object:nil queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification * _Nonnull note) {
                @synchronized (self) {
                    isKbVisible = NO;
                }
            }];
        }
    }

    return isKbVisible;
}
1
pthr

Um zu überprüfen, ob die Tastatur der Tastatur angezeigt wird, können wir die vordefinierten Benachrichtigungen der Tastatur verwenden.

UIKeyboardDidShowNotification, UIKeyboardDidHideNotification

Zum Beispiel kann ich den folgenden Code verwenden, um die Tastaturbenachrichtigung anzuhören

// Hören Sie auf das Auftreten und Verschwinden der Tastatur

[[NSNotificationCenter defaultCenter] addObserver:self 
                                         selector:@selector(keyboardDidShow:)
                                             name:UIKeyboardDidShowNotification
                                           object:nil];

[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(keyboardDidHide:)
                                             name:UIKeyboardDidHideNotification
                                           object:nil];

in den Methoden kann ich Benachrichtigungen erhalten

- (void)keyboardDidShow: (NSNotification *) notifyKeyBoardShow{
    // key board is closed
}

- (void)keyboardDidHide: (NSNotification *) notifyKeyBoardHide{
    // key board is opened
}
1
Manoj Singhal

Versuchen Sie diese Funktion

BOOL UIKeyboardIsVisible(){

BOOL keyboardVisible=NO;
// Locate non-UIWindow.
UIWindow *keyboardWindow = nil;
for (UIWindow *testWindow in [[UIApplication sharedApplication] windows]) {
    if (![[testWindow class] isEqual:[UIWindow class]]) {
        keyboardWindow = testWindow;
        break;
    }
}
// Locate UIKeyboard.
for (UIView *possibleKeyboard in [keyboardWindow subviews]) {
    // iOS 4 sticks the UIKeyboard inside a UIPeripheralHostView.
    if ([[possibleKeyboard description] hasPrefix:@"<UIPeripheralHostView"]) {
        keyboardVisible=YES;
    }
    if ([[possibleKeyboard description] hasPrefix:@"<UIKeyboard"]) {
        keyboardVisible=YES;
        break;
    }
}
return keyboardVisible;

}

von: iOS: Wie greife ich auf das UIKeyboard zu?

1
Vanguarder

Sie können alle Textansichten, Textfelder und Beschriftungen in den Unteransichten einer übergeordneten Ansicht iterativ überprüfen, um zu sehen, ob eine der ersten Antworten mit dem folgenden Element ist:

-(BOOL)isKeyboardActiveInView:(UIView *)view {
    for (UIView *anyView in [view subviews]) {
        if ([anyView isKindOfClass:[UITextField class]]) {
            if (((UITextField *)anyView).isFirstResponder) {
                return YES;
            }
        } else if ([anyView isKindOfClass:[UILabel class]]) {
            if (((UILabel *)anyView).isFirstResponder) {
                return YES;
            }
        } else if ([anyView isKindOfClass:[UITextView class]]) {
            if (((UITextView *)anyView).isFirstResponder) {
                return YES;
            }
        } else {
            if ([self isKeyboardActiveInView:anyView]) {
                return YES;
            }
        }
    }
    return NO;
}
0
Albert Renshaw

Swift 4.2/Swift 5

class Listener {
   public static let shared = Listener()
   var isVisible = false

   // Start this listener if you want to present the toast above the keyboard.
   public func startKeyboardListener() {
      NotificationCenter.default.addObserver(self, selector: #selector(didShow), name: UIResponder.keyboardWillShowNotification, object: nil)
      NotificationCenter.default.addObserver(self, selector: #selector(didHide), name: UIResponder.keyboardWillHideNotification, object: nil)
   }

   @objc func didShow() {
     isVisible = true
   }

    @objc func didHide(){
       isVisible = false
    }
}
0
Amrit Sidhu

Eine Erweiterung hinzufügen

extension UIApplication {   
/// Checks if view hierarchy of application contains `UIRemoteKeyboardWindow` if it does, keyboard is presented
var isKeyboardPresented: Bool {
    if let keyboardWindowClass = NSClassFromString("UIRemoteKeyboardWindow"), self.windows.contains(where: { $0.isKind(of: keyboardWindowClass) }) {
        return true
    } else {
        return false
    }
}

}

Dann prüfen, ob Tastatur vorhanden ist,

if UIApplication.shared.isKeyboardPresented {
     print("Keyboard presented")
} else { 
     print("Keyboard is not presented")
}
0
Kay Cee

Swift 4

extension UIViewController {
    func registerKeyboardNotifications() {
        let center = NotificationCenter.default
        center.addObserver(self, selector: #selector(keyboardWillBeShown(note:)), name: Notification.Name.UIKeyboardWillShow, object: nil)
        center.addObserver(self, selector: #selector(keyboardWillBeHidden(note:)), name: Notification.Name.UIKeyboardWillHide, object: nil)
    }

    func removeKeyboardNotifications() {
        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillShow, object: nil)
        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillHide, object: nil)

    }

    @objc
    func keyboardWillBeShown(note: Notification) {}

    @objc
    func keyboardWillBeHidden(note: Notification) {}

}

final class MyViewController: UIViewController {

    // MARK: - Properties
    var isKeyboardVisible = false

    // MARK: - Life Cycle
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        registerKeyboardNotifications()
    }

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

    // MARK: - Keyboard Handling
    override func keyboardWillBeShown(note: Notification) {
        isKeyboardVisible = true
        let userInfo = note.userInfo
        let keyboardFrame = userInfo?[UIKeyboardFrameEndUserInfoKey] as! CGRect
        let contentInset = UIEdgeInsetsMake(0.0, 0.0, keyboardFrame.height, 0.0)
        tableView.contentInset = contentInset
    }

   override func keyboardWillBeHidden(note: Notification) {
        tableView.contentInset = .zero
        isKeyboardVisible = false
   }

   // MARK: - Test
   fileprivate func test() {
        if isKeyboardVisible { // do something
        }
   }
}
0
Amber K