无需使用私有 API 即可获取当前第一响应者

Question

我在一个多星期前提交了我的应用程序，今天收到了可怕的拒绝电子邮件。它告诉我，我的应用程序无法被接受，因为我使用的是非公共 API；具体来说，它说，

您的应用程序中包含的非公共 API 是firstResponder。

现在，有问题的 API 调用实际上是我在 SO：

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

How do I get the currentfirst responder on the screen? 上找到的解决方案。我正在寻找一种不会让我的应用程序被拒绝的方法。

Answer 1

这就是我在用户单击 ModalViewController 中的“保存/取消”时查找 UITextField 是第一个响应者所做的事情：

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

            }
        }

    }

}

Answer 2

这就是我的 UIViewController 类别中的内容。对很多事情都很有用，包括获得急救人员。积木很棒！

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

Answer 3

您也可以这样尝试：

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

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

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

我没有尝试过，但这似乎是一个很好的解决方案

Answer 4

这是递归的良好候选者！无需向 UIView 添加类别。

用法（从您的视图控制器）：

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

代码：

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

Answer 5

@thomas-müller< 的 Swift 版本/a> 的回应

extension UIView {

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

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

        return nil
    }

}

Answer 6

更新：我错了。您确实可以使用 UIApplication.shared.sendAction(_:to:from:for:) 来调用此链接中演示的第一响应者：http://stackoverflow.com/a/14135456/746890。

---

如果当前的第一响应者不在视图层次结构中，这里的大多数答案都无法真正找到它。例如，AppDelegate 或 UIViewController 子类。

即使第一响应者对象不是 UIView，也有一种方法可以保证您找到它。

首先让我们使用 UIResponder 的 next 属性来实现它的反向版本：

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

通过这个计算属性，我们可以从下到上找到当前的第一响应者，即使它不是UIView。例如，从 view 到管理它的 UIViewController（如果视图控制器是第一响应者）。

然而，我们仍然需要一个自上而下的解析，一个var来获取当前的第一响应者。

首先是视图层次结构：

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

这将向后搜索第一个响应者，如果找不到它，它会告诉它的子视图做同样的事情（因为它的子视图的 next 不一定是它自己）。这样我们就可以从任何视图中找到它，包括UIWindow。

最后，我们可以构建这个：

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

所以当你想检索第一响应者时，你可以调用：

let firstResponder = UIResponder.first

Answer 7

您可以选择以下 UIView 扩展来获取它（由 Daniel 提供）：

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

Answer 8

你可以像这样调用私有API，苹果忽略：

UIWindow *keyWindow = [[UIApplication共享应用] keyWindow];
SEL sel = NSSelectorFromString(@"firstResponder");
UIView *firstResponder = [keyWindow PerformSelector:sel];

Answer 9

我想与您分享我在 UIView 的任何位置查找第一响应者的实现。我希望它有帮助，并对我的英语感到抱歉。谢谢

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

Answer 10

romeo https://stackoverflow.com/a/2799675/661022 的解决方案很酷，但我注意到代码还需要一个循环。我正在使用 tableViewController。
我编辑了脚本然后检查了。一切都很完美。

我建议尝试这个：

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

Answer 11

下面的代码有效。

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

Answer 12

如果您的最终目标只是辞职第一响应者，那么这应该有效：[self.view endEditing:YES]

Answer 13

在我的一个应用程序中，如果用户点击背景，我经常希望第一响应者辞职。为此，我在 UIView 上编写了一个类别，我在 UIWindow 上调用了该类别。

以下内容基于此，并且应该返回第一响应者。

@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 中的使用示例：

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

Answer 14

操纵第一响应者的常见方法是使用零目标操作。这是一种将任意消息发送到响应者链（从第一个响应者开始），并沿着链继续向下，直到有人响应该消息（已实现与选择器匹配的方法）的方法。

对于关闭键盘的情况，无论哪个窗口或视图是第一响应者，这都是最有效的方法：

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

这应该比 [self.view.window endEditing:YES]。

（感谢 BigZaphod 提醒我这个概念）

Answer 15

这里有一个类别，允许您通过调用[UIResponder currentFirstResponder]来快速找到第一响应者。只需将以下两个文件添加到您的项目中即可：

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

这里的技巧是将操作发送到 nil 将其发送到第一响应者。

（我最初在这里发布了这个答案：https://stackoverflow.com/a/14135456/322427）

Answer 16

这是基于 Jakob Egger 最优秀的答案在 Swift 中实现的扩展：

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

---

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

Answer 17

这并不漂亮，但是当我不知道响应者是什么时，我辞职的方式是：

创建一个 UITextField，无论是在 IB 中还是以编程方式。使其隐藏。如果您是在 IB 中制作的，请将其链接到您的代码。

然后，当您想要关闭键盘时，将响应者切换到不可见的文本字段，并立即退出它：

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

Answer 18

对于 Swift 3 和nevyn 答案的 4 版：

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

Answer 19

这是一个报告正确的第一响应者的解决方案（例如，许多其他解决方案不会将 UIViewController 报告为第一响应者），不需要在视图层次结构上循环，并且不使用私有 API。

它利用Apple的方法 sendAction:to:from:forEvent:，它已经知道如何访问第一响应者。

我们只需要通过两种方式调整它：

• 扩展UIResponder，以便它可以在第一响应者上执行我们自己的代码。
• 子类 UIEvent 以返回第一个响应者。

这是代码：

@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

Answer 20

使用Swift和特定的UIView对象这可能会有所帮助：

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
}

只需将它放在你的UIViewController中并像这样使用它this：

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

请注意，结果是一个可选值，因此如果在给定视图子视图层次结构中找不到firstResponder，则结果将为nil。

Answer 21

第一响应者可以是 UIResponder 类的任何实例，因此尽管有 UIView，但还有其他类可能是第一响应者。例如，UIViewController 也可能是第一响应者。

在 this gist 中，您将找到一种递归方法，通过循环遍历控制器的层次结构来获取第一个响应者从应用程序窗口的 rootViewController 开始。

您可以通过执行以下操作来检索第一响应者

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

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

但是，如果第一响应者不是 UIView 或 UIViewController 的子类，则此方法将失败。

为了解决这个问题，我们可以采用不同的方法，在 UIResponder 上创建一个类别，并执行一些神奇的调整，以便能够构建该类的所有活动实例的数组。然后，为了获得第一响应者，我们可以简单地迭代并询问每个对象是否-isFirstResponder。

这种方法可以在这个其他要点中找到实现。

希望有帮助。

Answer 22

迭代可能是第一响应者的视图，并使用 - (BOOL)isFirstResponder 来确定它们当前是否是。

Answer 23

我也向 nil 发送一条消息，而不是遍历视图集合来查找设置了 isFirstResponder 的视图，但我存储了消息的接收者，以便我可以返回它并用它做我想做的事。

此外，我将调用本身中的 defer 语句中保存找到的响应者的可选值清零。这可以确保在调用结束时不会保留任何引用（即使是较弱的引用）。

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 and place it in the _foundFirstResponder variable.
        // As such, the variable will contain the current first responder (if any) immediately after this line executes
        UIApplication.shared.sendAction(#selector(UIResponder.storeFirstResponder(_:)), to: nil, from: nil, for: nil)

        // The following 'defer' statement runs *after* this getter returns,
        // thus releasing any strong reference held by the variable immediately thereafter
        defer {
            _foundFirstResponder = nil
        }

        // Return the found first-responder (if any) back to the caller
        return _foundFirstResponder
    }

    // Make sure to mark this with '@objc' since it has to be reachable as a selector for `sendAction`
    @objc func storeFirstResponder(_ sender: AnyObject) {

        // Capture the recipient of this message (self), which is the first responder
        _foundFirstResponder = self
    }
}

通过上面的内容，我可以通过简单地执行此操作来辞职第一响应者...

UIResponder.first?.resignFirstResponder()

但是由于我的 API 实际上交还了第一响应者，所以我可以用它做任何我想做的事情。

下面的示例检查当前第一响应者是否是设置了 helpMessage 属性的 UITextField，如果是，则将其显示在控件旁边的帮助气泡中。我们通过屏幕上的“快速帮助”按钮调用它。

func showQuickHelp(){

    if let textField = UIResponder?.first as? UITextField,
       let helpMessage = textField.helpMessage {
    
        textField.showHelpBubble(with:helpMessage)
    }
}

对上述内容的支持是在 UITextField 的扩展中定义的，如下所示...

extension UITextField {
    var helpMessage:String? { ... }
    func showHelpBubble(with message:String) { ... }
}

现在要支持此功能，我们所要做的就是确定哪些文本字段有帮助消息，并且 UI 负责处理为我们休息。

Answer 24

Peter Steinberger 刚刚推文关于私人通知 UIWindowFirstResponderDidChangeNotification，您可以观察到如果你想观看firstResponder的变化。

Answer 25

如果您只需要在用户点击背景区域时关闭键盘，为什么不添加手势识别器并使用它来发送 [[self view] endEditing:YES] 消息？

您可以在 xib 或 Storyboard 文件中添加点击手势识别器并将其连接到一个动作，

看起来像这样然后完成

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

Answer 26

这就是 Jakob Egger 的方法的 Swift 版本：

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
    }

}