¿Cómo puedo verificar mediante programación si hay un teclado presente en la aplicación iOS?


111

Necesito verificar el estado de visibilidad del teclado en mi aplicación iOS.

Pseudocódigo:

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

¿Cómo puedo comprobar esta condición?


¿Qué aplicación? ¿Que lenguaje? ¿Qué plataforma? ¿Mi mejor suposición es el iPhone?
Nick Bedford

4
Pregunta arreglada. ¡Que empiecen los juegos!
Robert Harvey

Quizás esto
Peter Wong

Respuestas:


68

… O tomar el camino más fácil:

Cuando ingresa un campo de texto, se convierte en el primer respondedor y aparece el teclado. Puede comprobar el estado del teclado con [myTextField isFirstResponder]. Si regresa YES, entonces el teclado está activo.


21
Buena solución, sin embargo, esto NO funcionará si se utiliza un teclado de hardware (no es inusual en el iPad).
Andrei Herford

4
Esto no responde a la pregunta. Esto le indica si el campo de texto es el primero en responder. Tengo un controlador de vista con varios controladores de vista secundarios, todos los cuales contienen UITextFields. Usando este método, no puedo decir desde mi controlador de vista principal si se muestra el teclado. La única forma confiable es utilizar el método de notificación explicado en las otras respuestas
TimWhiting

63

El código de drawnonward es muy parecido, pero choca con el espacio de nombres de UIKit y podría ser más fácil de usar.

@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
¿Por qué necesita su propia piscina?
Dan Rosenstark

18
+loades un método especial llamado por el tiempo de ejecución de Objective-C. Se llama para cada clase después de que se cargue el binario de la aplicación, pero antes de main()que se ingrese la función. No hay garantía de que un grupo de liberación automática esté activo.
rpetrich

1
MattDiPasquale: Si se elimina el método + load, sharedInstance nunca se inicializará. Dado que no hay garantía de que un grupo de liberación automática esté activo cuando el tiempo de ejecución invoca un método + load, es necesario envolver todas las llamadas a las clases proporcionadas por el sistema en caso de que llamen a la liberación automática.
rpetrich

3
¡Buena respuesta! Sé que esto tiene varios años, pero el NSAutoreleasePool alloc/ releaseahora se puede reemplazar rodeando el código en@autoreleasepool { }
chown

3
No olvide eliminar Observer, probablemente en el dealloc de KeyboardStateListener.
SushiGrass Jacob

32

Cree un UIKeyboardListenercuando sepa que el teclado no está visible, por ejemplo, llamando [UIKeyboardListener shared]desde 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: Puede usar +(void)loadpara llamar a init en esta clase de escucha para que funcione genéricamente como arrastrar y soltar en cualquier proyecto y se inicialice desde el segundo lanzamiento de la aplicación en lugar de tener que recordar iniciarlo en cualquier lugar.
Albert Renshaw

30

Creo que debe utilizar las notificaciones que se proporcionan sobre el teclado:

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

Notificaciones de teclado

Cuando el sistema muestra u oculta el teclado, publica varias notificaciones de teclado. Estas notificaciones contienen información sobre el teclado, incluido su tamaño, que puede usar para cálculos que involucran vistas en movimiento. Registrarse para recibir estas notificaciones es la única forma de obtener algunos tipos de información sobre el teclado. El sistema envía las siguientes notificaciones para eventos relacionados con el teclado:

* UIKeyboardWillShowNotification
* UIKeyboardDidShowNotification
* UIKeyboardWillHideNotification
* UIKeyboardDidHideNotification

Para obtener más información sobre estas notificaciones, consulte sus descripciones en Referencia de clase UIWindow. Para obtener información sobre cómo mostrar y ocultar el teclado, consulte Texto e Internet.


Revisé estas notificaciones, pero no sé cómo revisar estas notificaciones. Si pudiera publicar algún ejemplo, sería muy útil.
Jitendra Singh

2
Eche un vistazo a NSNotificationCenter. Tendrá que registrarse para recibir las notificaciones que le interesan. No olvide cancelar el registro cuando salga de su aplicación.
Thomas Müller

13

Implementación de 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
Recomiendo eliminar el observador en deinit o si es un controlador de vista a la vista desaparecerá
Juan Boero

3
No tiene sentido usar un deinit si se trata de un singleton porque nunca se definirá
Sirens

11

Usar la jerarquía de subvista de ventana como indicación para mostrar el teclado es un truco. Si Apple cambia su implementación subyacente, todas estas respuestas se romperían.

La forma correcta sería monitorear la visualización del teclado y ocultar las notificaciones en toda la aplicación, como dentro de su Delegado de aplicación:

En AppDelegate.h:

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (assign, nonatomic) BOOL keyboardIsShowing;

@end

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

Entonces puedes verificar usando:

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

Debe tenerse en cuenta que las notificaciones de mostrar / ocultar el teclado no se activarán cuando el usuario esté usando un teclado bluetooth o externo.


10

Agregar una extensión

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

Luego verifique si el teclado está presente,

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

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

5

Esto es de la Guía de programación de texto de iOS publicada por Apple aquí: https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/TextAndWebiPhoneOS/KeyboardManagement/KeyboardManagement.html

Básicamente, llame a "registerForKeyBoardNotifications" en su ViewDidLoad. Luego, cada vez que el teclado se activa, se llama a "keyboardWasShown". Y cada vez que el teclado desaparece, se llama a "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

Ahora en iOS8 esta solución, por supuesto, no funciona. Fue escrito inicialmente para IOS4 / 5.

Prueba esta solución:

- (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
No es válido suponer que varias ventanas implican un teclado y que el teclado siempre es el segundo elemento.
jmah

1
@jmah Por supuesto, no es el enfoque universal, pero cubre una gran cantidad de casos de aplicación. Cualquier intento de obtener información sobre el teclado usa alguna jerarquía de vista específica porque Apple no proporciona ninguna API útil para este caso.
malex

Esto no funciona, lo que funcionó para mí fue iterar a través de todas las vistas y para todos los UITextFields o UITextView verifique si son los primeros en responder ... si alguno de ellos devuelve el teclado verdadero es visible, de lo contrario no es
amd

4

Algunas observaciones:

El patrón recomendado para un objeto singleton sería el siguiente. dispatch_once se asegura de que la clase se inicialice una vez de forma segura para subprocesos y que la variable estática no sea visible en el exterior. Y es GCD estándar, por lo que no es necesario conocer detalles de bajo nivel de Objective-C.

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

    return shared;
}

Por lo general, no solo desea saber si el teclado es visible o no, sino qué tan grande es. No todos los teclados tienen el mismo tamaño. Los teclados de iPhone son más pequeños que los de iPad. Entonces querría otra propiedad @property (readonly, nonatomic) CGRect keyboardRect;que se establece en el método noticeShowKeyboard: como este:

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

Es importante notar que el rectángulo está en las coordenadas UIWindow y no respeta la rotación de la pantalla. Entonces, la persona que llama convertiría ese rectángulo llamando

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

Si el usuario gira la pantalla mientras el teclado está visible, se le dirá a la aplicación que el teclado está oculto y luego se mostrará nuevamente. Cuando se muestra, lo más probable es que todavía no se hayan rotado otras vistas. Entonces, si observa que el teclado oculta / muestra eventos usted mismo, convierta las coordenadas cuando realmente las necesite, no en la notificación.

Si el usuario divide o desacopla el teclado, o usa un teclado de hardware, las notificaciones siempre mostrarán el teclado como oculto. Desacoplar o fusionar el teclado enviará una notificación de "teclado mostrado".

El oyente debe inicializarse mientras el teclado está oculto; de lo contrario, se perderá la primera notificación y se asumirá que el teclado está oculto cuando no lo esté.

Por eso es muy importante saber lo que realmente quiere. Este código es útil para mover cosas fuera del camino del teclado (con un teclado dividido o desacoplado, eso es responsabilidad del usuario). No le dice si el usuario puede ver un teclado en la pantalla (en el caso de un teclado dividido). No le dice si el usuario puede escribir (por ejemplo, cuando hay un teclado de hardware). Mirar otras ventanas no funciona si la aplicación crea otras ventanas por sí misma.


Buenas advertencias sobre el teclado en iPad, ¡gracias!
JOM

3

Implementación rápida :

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

Debido a que swift no ejecuta el método de carga de clases al inicio, es importante iniciar este servicio al iniciar la aplicación:

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

Usando iOS 13, swift 5.0 en este último bit, ¿la carga de clases no parece ser necesaria?
user3069232

3

Esta es mi solución, encapsula todo en un solo método estático, y puede llamarlo en cualquier lugar para verificar:

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

Y así es como se hace en 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");
}

No olvide cancelar el registro:

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

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

Y si desea cerrar el teclado al presionar el botón "Regresar":

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

Prueba esta función

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;

}

desde: iOS: ¿Cómo acceder al `UIKeyboard`?


1

BOOL isTxtOpen = [txtfieldObjct isFirstReponder]. Si devuelve SÍ, entonces el teclado está activo.


1

Para comprobar si aparece el teclado meteorológico, podemos utilizar las notificaciones predefinidas del teclado.

UIKeyboardDidShowNotification, UIKeyboardDidHideNotification

Por ejemplo, puedo usar el siguiente código para escuchar la notificación del teclado

// Escuche las apariciones y desapariciones del teclado

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

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

en los métodos puedo recibir notificaciones

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

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

1

Rápido 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
        }
   }
}

Funciona muy bien para mí (Xcode 10.2, Swift4) solo tengo curiosidad por saber por qué nadie votó a favor de esto.
infinity_coding7

No, eso no funciona si el teclado ya fue presentado por un controlador de vista anterior.
Ricardo

0

Puede verificar iterativamente todas las vistas de texto, campos de texto y etiquetas en las subvistas de una vista principal para ver si alguna es la primera respuesta con algo como esto:

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

Eso falla si tiene controladores de vista infantil
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

Creo que esto puede ayudarte

+(BOOL)isKeyBoardInDisplay  {

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

    return isExists;
}

Gracias,

Naveen Shan


1
¡En iOS 6, Only Works aún no ha aparecido! Una vez que el teclado se ha mostrado una vez, deja de funcionar.
James Laurenstin
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.