Comment puis-je vérifier par programme si un clavier est présent dans l'application iOS?


111

Je dois vérifier la condition de visibilité du clavier dans mon application iOS.

Pseudocode:

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

Comment puis-je vérifier cette condition?


Quelle application? Quelle langue? Quelle plateforme? Ma meilleure estimation est l'iPhone?
Nick Bedford le

4
Question résolue. Que les jeux commencent!
Robert Harvey du

Peut -
Peter Wong

Réponses:


68

… Ou prenez la voie la plus simple:

Lorsque vous entrez un textField, il devient le premier répondeur et le clavier apparaît. Vous pouvez vérifier l'état du clavier avec [myTextField isFirstResponder]. S'il revient YES, alors le clavier est actif.


21
Bonne solution, cependant cela ne fonctionnera PAS, si un clavier matériel est utilisé (ce qui n'est pas inhabituel sur l'iPad).
Andrei Herford

4
Cela ne répond pas à la question. Cela vous indique si le champ de texte est le premier répondant. J'ai un contrôleur de vue avec plusieurs contrôleurs de vue enfants, qui contiennent tous des UITextFields. En utilisant cette méthode, je ne peux pas dire à partir de mon contrôleur de vue parent si le clavier est affiché. Le seul moyen fiable est d'utiliser la méthode de notification expliquée dans les autres réponses
TimWhiting

63

Le code de drawonward est très proche, mais entre en collision avec l'espace de noms d'UIKit et pourrait être rendu plus facile à utiliser.

@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

4
Pourquoi a-t-il besoin de sa propre piscine?
Dan Rosenstark

18
+loadest une méthode spéciale appelée par le runtime Objective-C. Il est appelé pour chaque classe après le chargement du binaire de l'application, mais avant l' main()entrée de la fonction. Il n'y a aucune garantie qu'une piscine autorelease sera active.
rpetrich

1
MattDiPasquale: Si la méthode + load est supprimée, sharedInstance ne sera jamais initialisé. Puisqu'il n'y a aucune garantie qu'un pool de libération automatique est actif lorsque le moteur d'exécution appelle une méthode + load, l'encapsulation de tous les appels aux classes fournies par le système est nécessaire au cas où ils appelleraient autorelease.
rpetrich le

3
Bonne réponse! Je sais que cela date de plusieurs années, mais le NSAutoreleasePool alloc/ releasepeut maintenant être remplacé en entourant le code dans@autoreleasepool { }
chown

3
N'oubliez pas de supprimer l'Observer, probablement dans le dealloc de KeyboardStateListener.
SushiGrass Jacob

32

Créez un UIKeyboardListenerlorsque vous savez que le clavier n'est pas visible, par exemple en appelant [UIKeyboardListener shared]depuis applicationDidFinishLaunching.

@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

Remarque: vous pouvez utiliser +(void)loadpour appeler init sur cette classe d'écouteur afin qu'il fonctionne de manière générique comme un glisser-déposer dans n'importe quel projet et s'initialise à partir du deuxième lancement d'application plutôt que de vous rappeler de l'initier n'importe où.
Albert Renshaw

30

Je pense que vous devez utiliser les notifications fournies sur le clavier:

De: http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITextField_Class/Reference/UITextField.html

Notifications clavier

Lorsque le système affiche ou masque le clavier, il publie plusieurs notifications clavier. Ces notifications contiennent des informations sur le clavier, y compris sa taille, que vous pouvez utiliser pour les calculs impliquant des vues en mouvement. L'inscription à ces notifications est le seul moyen d'obtenir certains types d'informations sur le clavier. Le système délivre les notifications suivantes pour les événements liés au clavier:

* UIKeyboardWillShowNotification
* UIKeyboardDidShowNotification
* UIKeyboardWillHideNotification
* UIKeyboardDidHideNotification

Pour plus d'informations sur ces notifications, consultez leurs descriptions dans Référence de classe UIWindow. Pour plus d'informations sur l'affichage et le masquage du clavier, voir Texte et Web.


J'ai vérifié ces notifications, mais je ne sais pas comment vérifier ces notifications. Si vous pouviez publier un exemple, ce serait très utile.
Jitendra Singh

2
Jetez un œil à NSNotificationCenter. Vous devrez vous inscrire aux notifications qui vous intéressent. N'oubliez pas de vous désinscrire à la fermeture de votre application.
Thomas Müller

13

Implémentation Swift 3

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

1
Je recommande de supprimer l'observateur dans deinit ou si son contrôleur de vue disparaîtra
Juan Boero

3
Il ne sert à rien d'utiliser un deinit s'il s'agit d'un singleton car il ne sera jamais défini
Sirens

11

Utiliser la hiérarchie des sous-vues de la fenêtre comme indication pour l'affichage du clavier est un hack. Si Apple modifiait sa mise en œuvre sous-jacente, toutes ces réponses seraient rompues.

La bonne façon serait de surveiller l'affichage du clavier et de masquer les notifications à l'échelle de l'application, par exemple à l'intérieur de votre délégué d'application:

Dans AppDelegate.h:

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (assign, nonatomic) BOOL keyboardIsShowing;

@end

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

Ensuite, vous pouvez vérifier en utilisant:

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

Il convient de noter que les notifications d'affichage / masquage du clavier ne se déclenchent pas lorsque l'utilisateur utilise un clavier Bluetooth ou externe.


10

Ajouter une extension

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

Vérifiez ensuite si le clavier est présent,

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

Can doguard let keyboardWindowClass = NSClassFromString("UIRemoteKeyboardWindow") else { return false }; return UIApplication.shared.windows.contains(where: { $0.isKind(of: keyboardWindowClass) })
Clay Bridges le

5

Ceci provient du guide de programmation texte iOS publié par Apple ici: https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/TextAndWebiPhoneOS/KeyboardManagement/KeyboardManagement.html

Appelez essentiellement "registerForKeyBoardNotifications" dans votre ViewDidLoad. Ensuite, chaque fois que le clavier devient actif, "keyboardWasShown" est appelé. Et chaque fois que le clavier disparaît, "keyboardWillBeHidden" est appelé.

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

Maintenant, dans iOS8, cette solution ne fonctionne bien sûr pas. Il a été initialement écrit pour IOS4 / 5.

Essayez cette solution:

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

2
Il est invalide de supposer que plusieurs fenêtres impliquent un clavier et que le clavier est toujours le deuxième élément.
jmah

1
@jmah Bien sûr, ce n'est pas l'approche universelle, mais elle couvre un grand nombre de cas d'application. Toute tentative pour obtenir des informations sur le clavier utilise une hiérarchie de vues spécifique, car Apple ne fournit aucune API utile pour ce cas.
malex

Cela ne fonctionne pas, ce qui a fonctionné pour moi était itérer à travers toutes les vues et pour tous UITextFields ou UITextView vérifier si elles sont les premiers intervenants ... si l' un de puis revenir vrai clavier est visible le reste de sa non
amd

4

Quelques observations:

Le modèle recommandé pour un objet singleton serait le suivant. dispatch_once s'assure que la classe est initialisée une fois de manière thread-safe et que la variable statique n'est pas visible à l'extérieur. Et c'est un GCD standard, donc pas besoin de connaître les détails de bas niveau d'Objective-C.

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

    return shared;
}

Habituellement, vous ne voulez pas savoir si le clavier est visible ou non, mais quelle est sa taille. Les claviers n'ont pas tous la même taille. Les claviers iPhone sont plus petits que les claviers iPad. Vous voudriez donc une autre propriété @property (readonly, nonatomic) CGRect keyboardRect;définie dans la méthode noticeShowKeyboard: comme celle-ci:

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

Il est important de noter que le rectangle est en coordonnées UIWindow et ne respecte pas la rotation de l'écran. Ainsi, l'appelant convertirait ce rectangle en appelant

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

Si l'utilisateur fait pivoter l'écran alors que le clavier est visible, l'application sera informée que le clavier est masqué, puis affichée à nouveau. Lorsqu'il est affiché, les autres vues ne sont probablement pas encore pivotées. Donc, si vous observez vous-même les événements de masquage / affichage du clavier, convertissez les coordonnées lorsque vous en avez réellement besoin, pas dans la notification.

Si l'utilisateur divise ou déverrouille le clavier, ou utilise un clavier matériel, les notifications afficheront toujours le clavier comme masqué. Le désancrage ou la fusion du clavier enverra une notification «clavier affiché».

L'auditeur doit être initialisé alors que le clavier est masqué, sinon la première notification sera manquée, et on supposera que le clavier est masqué quand ce n'est pas le cas.

Il est donc très important de savoir ce que vous voulez réellement. Ce code est utile pour déplacer les choses hors du chemin du clavier (avec un clavier partagé ou non ancré, c'est la responsabilité de l'utilisateur). Il ne vous dit pas si l'utilisateur peut voir un clavier à l'écran (en cas de clavier partagé). Il ne vous dit pas si l'utilisateur peut taper (par exemple quand il y a un clavier matériel). Regarder d'autres fenêtres ne fonctionne pas si l'application crée elle-même d'autres fenêtres.


Bons avertissements sur le clavier de l'iPad, merci!
JOM

3

Mise en œuvre rapide :

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

Étant donné que swift n'exécute pas la méthode de chargement de classe au démarrage, il est important de démarrer ce service au lancement de l'application:

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

En utilisant iOS 13, swift 5.0 ce dernier bit, le chargement de classe ne semble pas nécessaire?
user3069232

3

C'est ma solution, elle encapsule tout dans une seule méthode statique, et vous pouvez l'appeler n'importe où pour vérifier:

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

2

Et voici comment le faire dans 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");
}

N'oubliez pas de vous désinscrire:

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

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

Et si vous souhaitez fermer le clavier en appuyant sur le bouton "Retour":

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

}

1

Essayez cette fonction

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;

}

depuis: iOS: Comment accéder au `UIKeyboard`?


1

BOOL isTxtOpen = [txtfieldObjct isFirstReponder]. S'il renvoie OUI, alors le clavier est actif.


1

Pour vérifier que le clavier météo est apparu, nous pouvons utiliser les notifications prédéfinies du clavier.

UIKeyboardDidShowNotification, UIKeyboardDidHideNotification

Par exemple, je peux utiliser le code suivant pour écouter la notification du clavier

// Écoutez les apparitions et les disparitions au clavier

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

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

dans les méthodes, je peux recevoir des notifications

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

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

1

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

Fonctionne très bien pour moi (Xcode 10.2, Swift4) juste curieux de savoir pourquoi personne n'a voté pour cela?
infinity_coding7

Non, cela ne fonctionne pas si le clavier était déjà présenté par un contrôleur de vue précédent.
Ricardo

0

Vous pouvez vérifier de manière itérative toutes les vues de texte, les champs de texte et les étiquettes dans les sous-vues d'une vue parente pour voir si l'une d'entre elles est le premier répondant avec quelque chose comme ceci:

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

Cela échoue si vous avez des contrôleurs de vue enfants
Ricardo

-1

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

-5

Je pense que cela peut t'aider,

+(BOOL)isKeyBoardInDisplay  {

    BOOL isExists = NO;
    for (UIWindow *keyboardWindow in [[UIApplication sharedApplication] windows])   {
        if ([[keyboardWindow description] hasPrefix:@"<UITextEffectsWindow"] == YES) {
            isExists = YES;
        }  
    }

    return isExists;
}

Merci,

Naveen Shan


1
Sur iOS 6, Only works n'est pas encore apparu! Une fois que le clavier a été montré une fois, il cesse de fonctionner.
James Laurenstin
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.