Come posso verificare a livello di codice se una tastiera è presente nell'app iOS?


111

Devo controllare le condizioni di visibilità della tastiera nella mia app iOS.

pseudocodice:

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

Come posso controllare questa condizione?


Quale app? Quale lingua? Quale piattaforma? La mia ipotesi migliore è iPhone?
Nick Bedford,

4
Domanda risolta. Che i giochi inizino!
Robert Harvey,


Risposte:


68

... o prendi il modo più semplice:

Quando si immette un textField, diventa il primo risponditore e viene visualizzata la tastiera. Puoi controllare lo stato della tastiera con [myTextField isFirstResponder]. Se ritorna YES, la tastiera è attiva.


21
Buona soluzione, tuttavia questo NON funzionerà, se viene utilizzata una tastiera hardware (cosa non insolita su iPad).
Andrei Herford,

4
Questo non risponde alla domanda. Questo ti dice se il campo di testo è il primo risponditore. Ho un controller di visualizzazione con più controller di visualizzazione figlio, che contengono tutti UITextFields. Utilizzando questo metodo, non posso dire dal mio controller di visualizzazione genitore se viene mostrata la tastiera. L'unico modo affidabile è utilizzare il metodo di notifica spiegato nelle altre risposte
TimWhiting

63

Il codice di drawnonward è molto simile, ma collide con lo spazio dei nomi di UIKit e potrebbe essere reso più facile da usare.

@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
Perché ha bisogno della sua piscina?
Dan Rosenstark

18
+loadè un metodo speciale chiamato dal runtime Objective-C. Viene chiamato per ogni classe dopo il caricamento del file binario dell'app, ma prima che main()venga inserita la funzione. Non vi è alcuna garanzia che un pool di rilascio automatico sarà attivo.
rpetrich

1
MattDiPasquale: se il metodo + load viene eliminato, sharedInstance non verrà mai inizializzato. Poiché non vi è alcuna garanzia che un pool di rilascio automatico sia attivo quando il runtime richiama un metodo + load, è necessario eseguire il wrapping di tutte le chiamate alle classi fornite dal sistema nel caso in cui chiamino autorelease.
rpetrich

3
Bella risposta! So che ha diversi anni ma ora NSAutoreleasePool alloc/ releasepuò essere sostituito circondando il codice in@autoreleasepool { }
chown

3
Non dimenticare di rimuovere Observer, probabilmente nel dealloc di KeyboardStateListener.
SushiGrass Jacob

32

Crea un messaggio UIKeyboardListenerquando sai che la tastiera non è visibile, ad esempio chiamando [UIKeyboardListener shared]da 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

Nota: puoi usare +(void)loadper chiamare init su questa classe listener in modo che funzioni genericamente come un drag-and-drop in qualsiasi progetto e inizializzi dal secondo avvio dell'app invece di doverti ricordare di iniziarlo ovunque.
Albert Renshaw

30

Penso che sia necessario utilizzare le notifiche fornite sulla tastiera:

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

Notifiche da tastiera

Quando il sistema mostra o nasconde la tastiera, pubblica diverse notifiche della tastiera. Queste notifiche contengono informazioni sulla tastiera, comprese le sue dimensioni, che puoi utilizzare per i calcoli che coinvolgono lo spostamento delle viste. La registrazione per queste notifiche è l'unico modo per ottenere alcuni tipi di informazioni sulla tastiera. Il sistema fornisce le seguenti notifiche per gli eventi relativi alla tastiera:

* UIKeyboardWillShowNotification
* UIKeyboardDidShowNotification
* UIKeyboardWillHideNotification
* UIKeyboardDidHideNotification

Per ulteriori informazioni su queste notifiche, vedere le relative descrizioni in Riferimento alla classe UIWindow. Per informazioni su come mostrare e nascondere la tastiera, vedere Testo e Web.


Ho controllato queste notifiche, ma non so come controllare queste notifiche. Se potessi pubblicare qualche esempio, sarebbe molto utile.
Jitendra Singh,

2
Dai un'occhiata a NSNotificationCenter. Dovrai registrarti per le notifiche che ti interessano. Non dimenticare di annullare la registrazione quando la tua applicazione esce.
Thomas Müller,

13

Implementazione rapida 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
Consiglio di rimuovere l'osservatore in deinit o se è un controller di visualizzazione in vista scomparirà
Juan Boero

3
Non ha senso usare un deinit se questo è un singleton perché non verrà mai definito
Sirene

11

Usare la gerarchia della sottoview della finestra come indicazione per la visualizzazione della tastiera è un trucco. Se Apple cambiasse la loro implementazione sottostante, tutte queste risposte non funzionerebbero.

Il modo corretto sarebbe monitorare la visualizzazione della tastiera e nascondere le notifiche in tutta l'applicazione, ad esempio all'interno del delegato dell'app:

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

Quindi puoi controllare usando:

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

Va notato che le notifiche di mostra / nascondi tastiera non si attiveranno quando l'utente utilizza una tastiera Bluetooth o esterna.


10

Aggiungi un'estensione

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

Quindi controlla se la tastiera è presente,

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

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

5

Questo è tratto dalla Guida alla programmazione di testo iOS pubblicata da Apple qui: https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/TextAndWebiPhoneOS/KeyboardManagement/KeyboardManagement.html

Fondamentalmente chiama "registerForKeyBoardNotifications" nel tuo ViewDidLoad. Quindi ogni volta che la tastiera diventa attiva, viene chiamato "keyboardWasShown". E ogni volta che la tastiera scompare, viene chiamato "keyboardWillBeHidden".

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

Ora in iOS8 questa soluzione ovviamente non funziona. Inizialmente è stato scritto per IOS4 / 5.

Prova questa soluzione:

- (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
Non è valido presumere che più finestre implichino una tastiera e che la tastiera sia sempre il secondo elemento.
jmah

1
@jmah Ovviamente non è l'approccio universale ma copre un'enorme quantità di casi di applicazione. Qualsiasi tentativo di ottenere informazioni sulla tastiera utilizza una gerarchia di visualizzazione specifica perché Apple non fornisce alcuna API utile per questo caso.
Malex

Questo non funziona, quello che ha funzionato per me è stato iterare attraverso tutte le viste e per tutti gli UITextFields o UITextView controlla se sono i primi soccorritori ... se qualcuno di poi restituisce la vera tastiera è visibile altrimenti non è
amd

4

Alcune osservazioni:

Il modello consigliato per un oggetto singleton sarebbe il seguente. dispatch_once si assicura che la classe venga inizializzata una volta in modo thread-safe e che la variabile statica non sia visibile all'esterno. Ed è GCD standard, quindi non è necessario conoscere i dettagli di basso livello di Objective-C.

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

    return shared;
}

Di solito non vuoi sapere solo se la tastiera è visibile o meno, ma quanto è grande. Le tastiere non hanno tutte le stesse dimensioni. Le tastiere dell'iPhone sono più piccole delle tastiere dell'iPad. Quindi vorresti un'altra proprietà @property (readonly, nonatomic) CGRect keyboardRect;che è impostata nel metodo noticeShowKeyboard: come questo:

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

È importante notare che il rettangolo è nelle coordinate di UIWindow e non rispetta la rotazione dello schermo. Quindi il chiamante convertirà quel rettangolo chiamando

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

Se l'utente ruota lo schermo mentre la tastiera è visibile, all'app verrà detto che la tastiera è nascosta, quindi mostrata di nuovo. Quando viene visualizzato, è molto probabile che altre visualizzazioni non siano ancora ruotate. Quindi, se osservi tu stesso gli eventi nascosti / mostrati dalla tastiera, converti le coordinate quando ne hai effettivamente bisogno, non nella notifica.

Se l'utente divide o sgancia la tastiera o utilizza una tastiera hardware, le notifiche mostreranno sempre la tastiera come nascosta. Lo scollegamento o l'unione della tastiera invierà una notifica "Tastiera visualizzata".

L'ascoltatore deve essere inizializzato mentre la tastiera è nascosta, altrimenti la prima notifica verrà persa e si presume che la tastiera sia nascosta quando non lo è.

Quindi è molto importante sapere cosa vuoi veramente. Questo codice è utile per spostare le cose dalla tastiera (con una tastiera divisa o sganciata, questa è la responsabilità dell'utente). Non ti dice se l'utente può vedere una tastiera sullo schermo (nel caso di una tastiera divisa). Non ti dice se l'utente può digitare (ad esempio quando è presente una tastiera hardware). Guardare altre finestre non funziona se l'app crea altre finestre.


Buoni avvertimenti sulla tastiera in iPad, grazie!
JOM

3

Rapida implementazione:

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

Poiché swift non esegue il metodo di caricamento della classe all'avvio, è importante avviare questo servizio all'avvio dell'app:

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

Utilizzando iOS 13, swift 5.0 quest'ultimo bit, il caricamento della classe non sembra essere necessario?
user3069232

3

Questa è la mia soluzione, incapsula tutto in un unico metodo statico e puoi chiamarlo ovunque per verificare:

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

Ed ecco come farlo 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");
}

Non dimenticare di annullare la registrazione:

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

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

E se desideri chiudere la tastiera premendo il pulsante "Invio":

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

Prova questa funzione

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;

}

da: iOS: come accedere a `UIKeyboard`?


1

BOOL isTxtOpen = [txtfieldObjct isFirstReponder]. Se restituisce YES, la tastiera è attiva.


1

Per verificare la comparsa della tastiera meteo, possiamo utilizzare le notifiche predefinite della tastiera.

UIKeyboardDidShowNotification, UIKeyboardDidHideNotification

Ad esempio posso utilizzare il codice seguente per ascoltare la notifica della tastiera

// Ascolta le apparizioni e le sparizioni della tastiera

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

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

nei metodi posso ricevere notifiche

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

Funziona molto bene per me (Xcode 10.2, Swift4), sono solo curioso di sapere perché nessuno ha votato questo?
infinity_coding7

No, non funziona se la tastiera era già stata presentata da un controller di visualizzazione precedente.
Ricardo

0

Puoi controllare iterativamente tutte le visualizzazioni di testo, i campi di testo e le etichette nelle visualizzazioni secondarie di una visualizzazione genitore per vedere se qualcuno è il primo risponditore con qualcosa del genere:

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

Ciò non riesce se si dispone di controller di visualizzazione figlio
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

Penso che questo possa aiutarti,

+(BOOL)isKeyBoardInDisplay  {

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

    return isExists;
}

Grazie,

Naveen Shan


1
Su iOS 6, Only works non è ancora apparso! Una volta che la tastiera è stata mostrata una volta, smette di funzionare.
James Laurenstin
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.