Özel bir API kullanmadan geçerli ilk yanıtlayıcıyı edinin

Uygulamamı bir haftadan biraz önce gönderdim ve bugün korkunç e-posta e-postasını aldım. Herkese açık olmayan bir API kullandığım için uygulamamın kabul edilemeyeceğini söylüyor; özellikle diyor ki,

Başvurunuzda bulunan herkese açık olmayan API, ilk Yanıtlayıcıdır.

Şimdi, rahatsız edici API çağrısı aslında burada SO buldum bir çözüm:

UIWindow *keyWindow = [[UIApplication sharedApplication] keyWindow];
UIView   *firstResponder = [keyWindow performSelector:@selector(firstResponder)];

Geçerli ilk yanıtlayıcıyı ekrana nasıl getirebilirim? Uygulamamı reddetmeyecek bir yol arıyorum.

Uygulamalarımdan birinde, kullanıcı arka plana dokunursa ilk yanıtlayıcının istifa etmesini isterim. Bu amaçla UIView üzerine UIWindow'da çağırdığım bir kategori yazdım.

Aşağıdakiler buna dayanmaktadır ve ilk yanıtlayıcıyı döndürmelidir.

@implementation UIView (FindFirstResponder)
- (id)findFirstResponder
{
    if (self.isFirstResponder) {
        return self;        
    }
    for (UIView *subView in self.subviews) {
        id responder = [subView findFirstResponder];
        if (responder) return responder;
    }
    return nil;
}
@end

iOS 7+

- (id)findFirstResponder
{
    if (self.isFirstResponder) {
        return self;
    }
    for (UIView *subView in self.view.subviews) {
        if ([subView isFirstResponder]) {
            return subView;
        }
    }
    return nil;
}

Swift:

extension UIView {
    var firstResponder: UIView? {
        guard !isFirstResponder else { return self }

        for subview in subviews {
            if let firstResponder = subview.firstResponder {
                return firstResponder
            }
        }

        return nil
    }
}

Swift'teki kullanım örneği:

if let firstResponder = view.window?.firstResponder {
    // do something with `firstResponder`
}

Nihai amacınız sadece ilk cevaplayıcıyı istifa etmekse, bu işe yaramalıdır: [self.view endEditing:YES]

İlk yanıtlayıcıyı değiştirmenin yaygın bir yolu, sıfır hedefli eylemler kullanmaktır. Bu, yanıtlayan zincirine rastgele bir mesaj göndermenin (ilk yanıtlayıcıdan başlayarak) ve birisi iletiye yanıt verene kadar (seçiciyle eşleşen bir yöntem uygulayana kadar) zinciri devam ettirmenin bir yoludur.

Klavyenin kapatılması durumunda, hangi pencere veya görünüm ilk yanıtlayıcı olursa olsun çalışacak en etkili yol budur:

[[UIApplication sharedApplication] sendAction:@selector(resignFirstResponder) to:nil from:nil forEvent:nil];

Bu daha da etkili olmalı [self.view.window endEditing:YES].

( BigZaphod'a bana konsepti hatırlattığı için teşekkürler )

İşte ilk yanıtlayıcıyı arayarak hızlı bir şekilde bulmanızı sağlayan bir kategori [UIResponder currentFirstResponder]. Projenize aşağıdaki iki dosyayı eklemeniz yeterlidir:

UIResponder + FirstResponder.h

#import <Cocoa/Cocoa.h>
@interface UIResponder (FirstResponder)
    +(id)currentFirstResponder;
@end

UIResponder + FirstResponder.m

#import "UIResponder+FirstResponder.h"
static __weak id currentFirstResponder;
@implementation UIResponder (FirstResponder)
    +(id)currentFirstResponder {
         currentFirstResponder = nil;
         [[UIApplication sharedApplication] sendAction:@selector(findFirstResponder:) to:nil from:nil forEvent:nil];
         return currentFirstResponder;
    }
    -(void)findFirstResponder:(id)sender {
        currentFirstResponder = self;
    }
@end

Buradaki hile, nil'e bir eylem göndermenin ilk yanıtlayıcıya göndermesidir.

(Aslında bu cevabı burada yayınladım: https://stackoverflow.com/a/14135456/322427 )

Swift'de Jakob Egger'in en mükemmel cevabına dayanan bir Uzantı:

import UIKit

extension UIResponder {
    // Swift 1.2 finally supports static vars!. If you use 1.1 see: 
    // http://stackoverflow.com/a/24924535/385979
    private weak static var _currentFirstResponder: UIResponder? = nil

    public class func currentFirstResponder() -> UIResponder? {
        UIResponder._currentFirstResponder = nil
        UIApplication.sharedApplication().sendAction("findFirstResponder:", to: nil, from: nil, forEvent: nil)
        return UIResponder._currentFirstResponder
    }

    internal func findFirstResponder(sender: AnyObject) {
        UIResponder._currentFirstResponder = self
    }
}

Hızlı 4

import UIKit    

extension UIResponder {
    private weak static var _currentFirstResponder: UIResponder? = nil

    public static var current: UIResponder? {
        UIResponder._currentFirstResponder = nil
        UIApplication.shared.sendAction(#selector(findFirstResponder(sender:)), to: nil, from: nil, for: nil)
        return UIResponder._currentFirstResponder
    }

    @objc internal func findFirstResponder(sender: AnyObject) {
        UIResponder._currentFirstResponder = self
    }
}

Güzel değil, ama cevaplayıcının ne olduğunu bilmediğimde firstResponder'ı istifa etmenin yolu:

IB veya programlı olarak bir UITextField oluşturun. Gizli yap. IB'de yaptıysanız kodunuza bağlayın.

Ardından, klavyeyi kapatmak istediğinizde, yanıtlayıcıyı görünmez metin alanına geçirir ve hemen istifa edersiniz:

    [self.invisibleField becomeFirstResponder];
    [self.invisibleField resignFirstResponder];

Nevyn'in cevabının Swift 3 ve 4 versiyonu için :

UIApplication.shared.sendAction(#selector(UIView.resignFirstResponder), to: nil, from: nil, for: nil)

İşte doğru ilk yanıtlayıcıyı bildiren bir çözüm (diğer birçok çözüm a'yı ilk yanıtlayıcı UIViewControllerolarak raporlamaz ), görünüm hiyerarşisinde döngü gerektirmez ve özel API'ler kullanmaz.

İlk yanıtlayıcıya nasıl erişileceğini zaten bilen Apple'ın sendAction: to: from: forEvent: yöntemini kullanır .

Sadece 2 şekilde ayarlamamız gerekiyor:

• UIResponderİlk yanıtlayıcıda kendi kodumuzu yürütebilmesi için genişletin .
• UIEventİlk yanıtlayıcıyı döndürmek için alt sınıf .

İşte kod:

@interface ABCFirstResponderEvent : UIEvent
@property (nonatomic, strong) UIResponder *firstResponder;
@end

@implementation ABCFirstResponderEvent
@end

@implementation UIResponder (ABCFirstResponder)
- (void)abc_findFirstResponder:(id)sender event:(ABCFirstResponderEvent *)event {
    event.firstResponder = self;
}
@end

@implementation ViewController

+ (UIResponder *)firstResponder {
    ABCFirstResponderEvent *event = [ABCFirstResponderEvent new];
    [[UIApplication sharedApplication] sendAction:@selector(abc_findFirstResponder:event:) to:nil from:nil forEvent:event];
    return event.firstResponder;
}

@end

İlk yanıtlayıcı UIResponder sınıfının herhangi bir örneği olabilir, bu nedenle UIViews'a rağmen ilk yanıtlayıcı olabilecek başka sınıflar da vardır. Örneğin UIViewController, ilk cevaplayıcı da olabilir.

Gelen bu Ana fikir uygulamanın pencerelerin rootViewController başlayarak denetleyicilerin hiyerarşisi döngü tarafından ilk yanıtlayıcısını almak için özyinelemeli yol bulacaktır.

Ardından ilk yanıtlayıcıyı

- (void)foo
{
    // Get the first responder
    id firstResponder = [UIResponder firstResponder];

    // Do whatever you want
    [firstResponder resignFirstResponder];      
}

Ancak, ilk yanıtlayıcı UIView veya UIViewController alt sınıfı değilse, bu yaklaşım başarısız olur.

Bu sorunu çözmek için, üzerinde bir kategori oluşturarak farklı bir yaklaşım UIResponderyapabiliriz ve bu sınıfın tüm canlı örneklerinden oluşan bir dizi oluşturabilmek için sihirli bir büyü yapabiliriz. Daha sonra, ilk yanıtlayıcıyı almak için basit yineleme yapabilir ve her nesneye olup olmadığını sorabiliriz -isFirstResponder.

Bu yaklaşım, bu diğer özde de uygulanabilir .

Umarım yardımcı olur.

Swift'i kullanmak ve belirli bir UIViewnesneyle bu yardımcı olabilir:

func findFirstResponder(inView view: UIView) -> UIView? {
    for subView in view.subviews as! [UIView] {
        if subView.isFirstResponder() {
            return subView
        }

        if let recursiveSubView = self.findFirstResponder(inView: subView) {
            return recursiveSubView
        }
    }

    return nil
}

Sadece içine yerleştirin UIViewControllerve şu şekilde kullanın:

let firstResponder = self.findFirstResponder(inView: self.view)

Sonucun Opsiyonel bir değer olduğuna dikkat edin, bu nedenle verilen görünümler alt görüntülemelerinde ilk Yanıtlayıcı bulunmaması durumunda sıfır olacaktır.

İlk yanıtlayıcı olabilecek görünümleri yineleyin ve - (BOOL)isFirstResponderşu anda olup olmadığını belirlemek için kullanın .

Peter Steinberger , ilk Yanıtlayıcı değişikliğini izlemek isteyip istemediğinizi görebileceğiniz özel bildirimi tweetlediUIWindowFirstResponderDidChangeNotification .

Kullanıcı bir arka plan alanına dokunduğunda klavyeyi öldürmeniz gerekiyorsa neden bir hareket tanıyıcı eklemeyin ve [[self view] endEditing:YES]mesajı göndermek için kullanmıyorsunuz ?

Dokunma hareketi tanıyıcıyı xib veya film şeridi dosyasına ekleyebilir ve bir eyleme bağlayabilirsiniz,

böyle bir şey görünüyor sonra bitmiş

- (IBAction)displayGestureForTapRecognizer:(UITapGestureRecognizer *)recognizer{
     [[self view] endEditing:YES];
}

Buradaki durum harika Jakob Egger'in yaklaşımının Swift versiyonudur:

import UIKit

private weak var currentFirstResponder: UIResponder?

extension UIResponder {

    static func firstResponder() -> UIResponder? {
        currentFirstResponder = nil
        UIApplication.sharedApplication().sendAction(#selector(self.findFirstResponder(_:)), to: nil, from: nil, forEvent: nil)
        return currentFirstResponder
    }

    func findFirstResponder(sender: AnyObject) {
        currentFirstResponder = self
    }

}

Kullanıcı bir ModalViewController Kaydet / İptal'i tıklattığında ne UITextField firstResponder olduğunu bulmak için yaptım:

    NSArray *subviews = [self.tableView subviews];

for (id cell in subviews ) 
{
    if ([cell isKindOfClass:[UITableViewCell class]]) 
    {
        UITableViewCell *aCell = cell;
        NSArray *cellContentViews = [[aCell contentView] subviews];
        for (id textField in cellContentViews) 
        {
            if ([textField isKindOfClass:[UITextField class]]) 
            {
                UITextField *theTextField = textField;
                if ([theTextField isFirstResponder]) {
                    [theTextField resignFirstResponder];
                }

            }
        }

    }

}

Bu benim UIViewController Kategorisi ne var. İlk cevaplayıcı dahil olmak üzere birçok şey için kullanışlıdır. Bloklar harika!

- (UIView*) enumerateAllSubviewsOf: (UIView*) aView UsingBlock: (BOOL (^)( UIView* aView )) aBlock {

 for ( UIView* aSubView in aView.subviews ) {
  if( aBlock( aSubView )) {
   return aSubView;
  } else if( ! [ aSubView isKindOfClass: [ UIControl class ]] ){
   UIView* result = [ self enumerateAllSubviewsOf: aSubView UsingBlock: aBlock ];

   if( result != nil ) {
    return result;
   }
  }
 }    

 return nil;
}

- (UIView*) enumerateAllSubviewsUsingBlock: (BOOL (^)( UIView* aView )) aBlock {
 return [ self enumerateAllSubviewsOf: self.view UsingBlock: aBlock ];
}

- (UIView*) findFirstResponder {
 return [ self enumerateAllSubviewsUsingBlock:^BOOL(UIView *aView) {
  if( [ aView isFirstResponder ] ) {
   return YES;
  }

  return NO;
 }];
}

Bir kategori ile UIResponder, UIApplicationnesneden yasal olarak ilk cevaplayıcının kim olduğunu söylemesini istemek mümkündür .

Bunu gör:

Bir iOS görünümüne, çocuklarından hangisinin ilk yanıtlayıcı statüsüne sahip olduğunu sormanın bir yolu var mı?

Almak için aşağıdaki UIViewuzantıyı seçebilirsiniz (Daniel tarafından kredi) :

extension UIView {
    var firstResponder: UIView? {
        guard !isFirstResponder else { return self }
        return subviews.first(where: {$0.firstResponder != nil })
    }
}

Bunu da deneyebilirsiniz:

- (void) touchesBegan: (NSSet *) touches withEvent: (UIEvent *) event { 

    for (id textField in self.view.subviews) {

        if ([textField isKindOfClass:[UITextField class]] && [textField isFirstResponder]) {
            [textField resignFirstResponder];
        }
    }
} 

Denemedim ama iyi bir çözüm gibi görünüyor

Romeo https://stackoverflow.com/a/2799675/661022 çözüm harika, ama kodun bir döngü daha gerektiğini fark ettim. TableViewController ile çalışıyordum. Senaryoyu düzenledim ve sonra kontrol ettim. Her şey mükemmel çalıştı.

Bunu denemek için recommed:

- (void)findFirstResponder
{
    NSArray *subviews = [self.tableView subviews];
    for (id subv in subviews )
    {
        for (id cell in [subv subviews] ) {
            if ([cell isKindOfClass:[UITableViewCell class]])
            {
                UITableViewCell *aCell = cell;
                NSArray *cellContentViews = [[aCell contentView] subviews];
                for (id textField in cellContentViews)
                {
                    if ([textField isKindOfClass:[UITextField class]])
                    {
                        UITextField *theTextField = textField;
                        if ([theTextField isFirstResponder]) {
                            NSLog(@"current textField: %@", theTextField);
                            NSLog(@"current textFields's superview: %@", [theTextField superview]);
                        }
                    }
                }
            }
        }
    }
}

Bu özyineleme için iyi bir aday! UIView'e kategori eklemenize gerek yok.

Kullanımı (görünüm denetleyicinizden):

UIView *firstResponder = [self findFirstResponder:[self view]];

Kod:

// This is a recursive function
- (UIView *)findFirstResponder:(UIView *)view {

    if ([view isFirstResponder]) return view; // Base case

    for (UIView *subView in [view subviews]) {
        if ([self findFirstResponder:subView]) return subView; // Recursion
    }
    return nil;
}

Bunun gibi privit api diyebilirsiniz, elma yoksay:

UIWindow *keyWindow = [[UIApplication sharedApplication] keyWindow];
SEL sel = NSSelectorFromString(@"firstResponder");
UIView   *firstResponder = [keyWindow performSelector:sel];

@ Thomas-müller'in yanıtının hızlı versiyonu

extension UIView {

    func firstResponder() -> UIView? {
        if self.isFirstResponder() {
            return self
        }

        for subview in self.subviews {
            if let firstResponder = subview.firstResponder() {
                return firstResponder
            }
        }

        return nil
    }

}

Buradakinden biraz daha farklı bir yaklaşımım var. isFirstResponderAyarlanmış olanı arayan görünümler koleksiyonunu yinelemek yerine , ben de bir mesaj gönderirim nil, ancak alıcıyı (varsa) saklarım, daha sonra arayanın gerçek örneği (tekrar varsa) alması için bu değeri döndürürüm .

import UIKit

private var _foundFirstResponder: UIResponder? = nil

extension UIResponder{

    static var first:UIResponder?{

        // Sending an action to 'nil' implicitly sends it to the
        // first responder, where we simply capture it for return
        UIApplication.shared.sendAction(#selector(UIResponder.storeFirstResponder(_:)), to: nil, from: nil, for: nil)

        // The following 'defer' statement executes after the return
        // While I could use a weak ref and eliminate this, I prefer a
        // hard ref which I explicitly clear as it's better for race conditions
        defer {
            _foundFirstResponder = nil
        }

        return _foundFirstResponder
    }

    @objc func storeFirstResponder(_ sender: AnyObject) {
        _foundFirstResponder = self
    }
}

Daha sonra bunu yaparak ilk yanıtlayıcıyı istifa edebilirim ...

return UIResponder.first?.resignFirstResponder()

Ama şimdi bunu da yapabilirim ...

if let firstResponderTextField = UIResponder?.first as? UITextField {
    // bla
}

UIView'in herhangi bir yerinde ilk yanıtlayıcıyı bulmak için uygulamamı sizinle paylaşmak istiyorum. Umarım İngilizcem için yardımcı olur ve özür dilerim. Teşekkürler

+ (UIView *) findFirstResponder:(UIView *) _view {

    UIView *retorno;

    for (id subView in _view.subviews) {

        if ([subView isFirstResponder])
        return subView;

        if ([subView isKindOfClass:[UIView class]]) {
            UIView *v = subView;

            if ([v.subviews count] > 0) {
                retorno = [self findFirstResponder:v];
                if ([retorno isFirstResponder]) {
                    return retorno;
                }
            }
        }
    }

    return retorno;
}

Aşağıdaki kod çalışır.

- (id)ht_findFirstResponder
{
    //ignore hit test fail view
    if (self.userInteractionEnabled == NO || self.alpha <= 0.01 || self.hidden == YES) {
        return nil;
    }
    if ([self isKindOfClass:[UIControl class]] && [(UIControl *)self isEnabled] == NO) {
        return nil;
    }

    //ignore bound out screen
    if (CGRectIntersectsRect(self.frame, [UIApplication sharedApplication].keyWindow.bounds) == NO) {
        return nil;
    }

    if ([self isFirstResponder]) {
        return self;
    }

    for (UIView *subView in self.subviews) {
        id result = [subView ht_findFirstResponder];
        if (result) {
            return result;
        }
    }
    return nil;
}   

Güncelleme: Yanılmışım. Gerçekten UIApplication.shared.sendAction(_:to:from:for:)bu bağlantıda gösterilen ilk yanıtlayıcıyı aramak için kullanabilirsiniz : http://stackoverflow.com/a/14135456/746890 .

Buradaki yanıtların çoğu, görünüm hiyerarşisinde değilse geçerli ilk yanıtlayıcıyı gerçekten bulamaz. Örneğin AppDelegateveya UIViewControlleralt sınıflar.

İlk yanıtlayıcı nesnesi a olmasa bile, onu bulmanızı garanti etmenin bir yolu vardır UIView.

İlk olarak, şu nextözelliği kullanarak tersine çevrilmiş bir sürümünü uygulayalım UIResponder:

extension UIResponder {
    var nextFirstResponder: UIResponder? {
        return isFirstResponder ? self : next?.nextFirstResponder
    }
}

Bu hesaplanan özellik sayesinde, geçerli olmasa bile, ilk yanıtlayıcıyı aşağıdan yukarıya doğru bulabiliriz UIView. Örneğin, bir gelen viewetmek UIViewControllergörünüm denetleyicisi ilk savunan ise, onu kimin yönettiğini.

Ancak, varmevcut ilk yanıtlayıcıyı elde etmek için yine de yukarıdan aşağıya bir çözünürlüğe ihtiyacımız var .

Önce görünüm hiyerarşisinde:

extension UIView {
    var previousFirstResponder: UIResponder? {
        return nextFirstResponder ?? subviews.compactMap { $0.previousFirstResponder }.first
    }
}

Bu, ilk yanıtlayıcıyı geriye doğru arayacaktır ve bulamazsa, alt görünümlerine aynı şeyi yapmasını söyler (çünkü alt görünümünün nextkendisi olması gerekmez). Bununla, dahil olmak üzere herhangi bir görünümden bulabilirsiniz UIWindow.

Ve son olarak, bunu yapabiliriz:

extension UIResponder {
    static var first: UIResponder? {
        return UIApplication.shared.windows.compactMap({ $0.previousFirstResponder }).first
    }
}

İlk yanıtlayıcıyı almak istediğinizde şunu arayabilirsiniz:

let firstResponder = UIResponder.first

İlk yanıtlayıcıyı bulmanın en kolay yolu:

func sendAction(_ action: Selector, to target: Any?, from sender: Any?, for event: UIEvent?) -> Bool

Varsayılan uygulama, eylem yöntemini verilen hedef nesneye veya hedef belirtilmezse ilk yanıtlayıcıya gönderir.

Sonraki adım:

extension UIResponder
{
    private weak static var first: UIResponder? = nil

    @objc
    private func firstResponderWhereYouAre(sender: AnyObject)
    {
        UIResponder.first = self
    }

    static var actualFirst: UIResponder?
    {
        UIApplication.shared.sendAction(#selector(findFirstResponder(sender:)), to: nil, from: nil, for: nil)
        return UIResponder.first
    }
}

Kullanımı: Sadece UIResponder.actualFirstkendi amaçlarınız için olsun .