Como navegar pelos campos de texto (botões Avançar / Concluído)

Como posso navegar por todos os meus campos de texto com o botão "Avançar" no teclado do iPhone?

O último campo de texto deve fechar o teclado.

Eu configurei o IB the Buttons (Next / Done), mas agora estou preso.

Eu implementei a ação textFieldShouldReturn, mas agora os botões Avançar e Concluído fecham o teclado.

No Cocoa para Mac OS X, você tem a próxima cadeia de respostas, onde é possível perguntar ao campo de texto qual controle deve ser o próximo foco. É isso que faz a tabulação entre os campos de texto funcionar. Mas como os dispositivos iOS não possuem teclado, apenas toque, esse conceito não sobreviveu à transição para o Cocoa Touch.

Isso pode ser feito facilmente de qualquer maneira, com duas suposições:

1. Todos os "tabs" UITextFieldestão na mesma visualização pai.
2. Sua "ordem de tabulação" é definida pela propriedade da tag.

Supondo que você possa substituir textFieldShouldReturn: como este:

-(BOOL)textFieldShouldReturn:(UITextField*)textField
{
  NSInteger nextTag = textField.tag + 1;
  // Try to find next responder
  UIResponder* nextResponder = [textField.superview viewWithTag:nextTag];
  if (nextResponder) {
    // Found next responder, so set it.
    [nextResponder becomeFirstResponder];
  } else {
    // Not found, so remove keyboard.
    [textField resignFirstResponder];
  }
  return NO; // We do not want UITextField to insert line-breaks.
}

Adicione um pouco mais de código e as suposições também podem ser ignoradas.

Swift 4.0

 func textFieldShouldReturn(_ textField: UITextField) -> Bool {
    let nextTag = textField.tag + 1
    // Try to find next responder
    let nextResponder = textField.superview?.viewWithTag(nextTag) as UIResponder!

    if nextResponder != nil {
        // Found next responder, so set it
        nextResponder?.becomeFirstResponder()
    } else {
        // Not found, so remove keyboard
        textField.resignFirstResponder()
    }

    return false
}

Se a super visão do campo de texto for um UITableViewCell, o próximo respondedor será

let nextResponder = textField.superview?.superview?.superview?.viewWithTag(nextTag) as UIResponder!

Existe uma solução muito mais elegante que me surpreendeu na primeira vez que a vi. Benefícios:

• Mais próximo da implementação do campo de texto OSX, onde um campo de texto sabe para onde o foco deve seguir
• Não depende da configuração ou uso de tags - que são frágeis da IMO para este caso de uso
• Pode ser estendido para trabalhar com ambos UITextFielde UITextViewcontroles - ou qualquer controle da interface do usuário da entrada do teclado
• Não bagunça seu controlador de exibição com o código delegado UITextField padrão
• Integra-se perfeitamente ao IB e pode ser configurado através da opção familiar arrastar e soltar para conectar tomadas.

Crie uma subclasse UITextField que tenha uma IBOutletpropriedade chamada nextField. Aqui está o cabeçalho:

@interface SOTextField : UITextField

@property (weak, nonatomic) IBOutlet UITextField *nextField; 

@end

E aqui está a implementação:

@implementation SOTextField

@end

No seu controlador de exibição, você criará o -textFieldShouldReturn:método delegate:

- (BOOL)textFieldShouldReturn:(UITextField *)textField {
    if ([textField isKindOfClass:[SOTextField class]]) {
        UITextField *nextField = [(SOTextField *)textField nextField];

        if (nextField) {
            dispatch_async(dispatch_get_current_queue(), ^{
                [nextField becomeFirstResponder];
            });
        }
        else {
            [textField resignFirstResponder];
        }
    }

    return YES;
}

No IB, altere seu UITextFields para usar a SOTextFieldclasse Em seguida, também no IB, defina o delegado para cada um dos 'SOTextFields' para 'Proprietário do arquivo' (que é exatamente onde você coloca o código para o método de delegação - textFieldShouldReturn). A beleza desse design é que agora você pode simplesmente clicar com o botão direito do mouse em qualquer campo de texto e atribuir a saída nextField ao próximo SOTextFieldobjeto que você deseja que seja o próximo respondedor.

Além disso, você pode fazer coisas legais como fazer um loop no campo de texto para que, depois que o último perca o foco, o primeiro receba o foco novamente.

Isso pode ser facilmente estendido para atribuir automaticamente a returnKeyTypede a SOTextFielda UIReturnKeyNextse houver um nextField atribuído - menos uma coisa configurada manualmente.

Aqui está um sem delegação:

tf1.addTarget(tf2, action: #selector(becomeFirstResponder), for: .editingDidEndOnExit)
tf2.addTarget(tf3, action: #selector(becomeFirstResponder), for: .editingDidEndOnExit)

ObjC:

[tf1 addTarget:tf2 action:@selector(becomeFirstResponder) forControlEvents:UIControlEventEditingDidEndOnExit];
[tf2 addTarget:tf3 action:@selector(becomeFirstResponder) forControlEvents:UIControlEventEditingDidEndOnExit];

Funciona usando a UIControlEventEditingDidEndOnExit UITextFieldação (principalmente desconhecida) .

Você também pode conectar isso facilmente no storyboard, para que nenhuma delegação ou código seja necessário.

Edit: na verdade, eu não consigo descobrir como conectar isso no storyboard. becomeFirstRespondernão parece ser uma ação oferecida para esse evento de controle, que é uma pena. Ainda assim, você pode conectar todos os seus campos de texto a uma única ação no seu ViewController, que determina qual o campo de texto com becomeFirstResponderbase no remetente (embora não seja tão elegante quanto a solução programática acima, para que o IMO faça isso com o código acima viewDidLoad).

Aqui está a minha solução para este problema.

Para resolver isso (e porque eu odeio confiar em tags para fazer coisas), decidi adicionar uma propriedade personalizada ao objeto UITextField. Em outras palavras, eu criei uma categoria no UITextField assim:

UITextField + Extended.h

@interface UITextField (Extended)

@property(retain, nonatomic)UITextField* nextTextField;

@end

UITextField + Extended.m

#import "UITextField+Extended.h"
#import <objc/runtime.h>

static char defaultHashKey;

@implementation UITextField (Extended)

- (UITextField*) nextTextField { 
    return objc_getAssociatedObject(self, &defaultHashKey); 
}

- (void) setNextTextField:(UITextField *)nextTextField{
    objc_setAssociatedObject(self, &defaultHashKey, nextTextField, OBJC_ASSOCIATION_RETAIN_NONATOMIC); 
}

@end

Agora, aqui está como eu o uso:

UITextField *textField1 = ...init your textfield
UITextField *textField2 = ...init your textfield
UITextField *textField3 = ...init your textfield

textField1.nextTextField = textField2;
textField2.nextTextField = textField3;
textField3.nextTextField = nil;

E implemente o método textFieldShouldReturn:

- (BOOL)textFieldShouldReturn:(UITextField *)theTextField {

    UITextField *next = theTextField.nextTextField;
    if (next) {
        [next becomeFirstResponder];
    } else {
        [theTextField resignFirstResponder];
    }

    return NO; 
}

Agora tenho um tipo de lista vinculada de UITextField, cada um sabendo quem é o próximo na fila.

Espero que ajude.

Uma extensão rápida que aplica a resposta do mxcl para tornar isso particularmente fácil (adaptado ao swift 2.3 pelo Traveler):

extension UITextField {
    class func connectFields(fields:[UITextField]) -> Void {
        guard let last = fields.last else {
            return
        }
        for i in 0 ..< fields.count - 1 {
            fields[i].returnKeyType = .Next
            fields[i].addTarget(fields[i+1], action: "becomeFirstResponder", forControlEvents: .EditingDidEndOnExit)
        }
        last.returnKeyType = .Done
        last.addTarget(last, action: #selector(UIResponder.resignFirstResponder), forControlEvents: .EditingDidEndOnExit)
    }
}

É fácil de usar:

UITextField.connectFields([field1, field2, field3])

A extensão definirá o botão de retorno como "Avançar" para todos, exceto o último campo, e "Concluído" para o último campo, e mudará o foco / dispensará o teclado quando estes forem tocados.

Swift <2.3

extension UITextField {
    class func connectFields(fields:[UITextField]) -> Void {
        guard let last = fields.last else {
            return
        }
        for var i = 0; i < fields.count - 1; i += 1 {
            fields[i].returnKeyType = .Next
            fields[i].addTarget(fields[i+1], action: "becomeFirstResponder", forControlEvents: .EditingDidEndOnExit)
        }
        last.returnKeyType = .Done
        last.addTarget(last, action: "resignFirstResponder", forControlEvents: .EditingDidEndOnExit)
    }
}

SWIFT 3: use assim -

UITextField.connectFields(fields: [field1, field2])

Extension:
    extension UITextField {
        class func connectFields(fields:[UITextField]) -> Void {
            guard let last = fields.last else {
                return
            }
            for i in 0 ..< fields.count - 1 {
                fields[i].returnKeyType = .next
                fields[i].addTarget(fields[i+1], action: #selector(UIResponder.becomeFirstResponder), for: .editingDidEndOnExit)
            }
            last.returnKeyType = .go
            last.addTarget(last, action: #selector(UIResponder.resignFirstResponder), for: .editingDidEndOnExit)
        }
    }

Uma maneira mais consistente e robusta é usar o NextResponderTextField Você pode configurá-lo totalmente a partir do construtor de interface, sem a necessidade de definir ou usar o delegado view.tag.

Tudo que você precisa fazer é

1. Defina o tipo de classe de seu UITextFieldserNextResponderTextField
2. Em seguida, defina a saída do nextResponderFieldpara apontar para o próximo respondedor, pois pode ser qualquer coisa UITextFieldou qualquer UIRespondersubclasse. Também pode ser um UIButton e a biblioteca é inteligente o suficiente para acionar o TouchUpInsideevento do botão apenas se estiver ativado.

Aqui está a biblioteca em ação:

Gosto das soluções OO que já foram sugeridas pelo Anth0 e pelo Answerbot. No entanto, eu estava trabalhando em um POC rápido e pequeno, então não queria desorganizar as coisas com subclasses e categorias.

Outra solução simples é criar um NSArray de campos e procurar o próximo campo quando você pressionar próximo. Não é uma solução OO, mas é rápida, simples e fácil de implementar. Além disso, você pode ver e modificar a ordem rapidamente.

Aqui está o meu código (criado com base em outras respostas neste tópico):

@property (nonatomic) NSArray *fieldArray;

- (void)viewDidLoad {
    [super viewDidLoad];

    fieldArray = [NSArray arrayWithObjects: firstField, secondField, thirdField, nil];
}

- (BOOL) textFieldShouldReturn:(UITextField *) textField {
    BOOL didResign = [textField resignFirstResponder];
    if (!didResign) return NO;

    NSUInteger index = [self.fieldArray indexOfObject:textField];
    if (index == NSNotFound || index + 1 == fieldArray.count) return NO;

    id nextField = [fieldArray objectAtIndex:index + 1];
    activeField = nextField;
    [nextField becomeFirstResponder];

    return NO;
}

• Eu sempre retorno NÃO porque não quero inserir uma quebra de linha. Apenas pensei em salientar que, quando retornasse YES, sairia automaticamente dos campos subsequentes ou inseriria uma quebra de linha no meu TextView. Levei um pouco de tempo para descobrir isso.
• O activeField mantém o controle do campo ativo, caso seja necessário rolar a tela para desobstruir o campo do teclado. Se você tiver um código semelhante, atribua o activeField antes de alterar o primeiro respondedor. A alteração da primeira resposta é imediata e acionará o evento KeyboardWasShown imediatamente.

Aqui está uma implementação de tabulação usando uma categoria no UIControl. Esta solução tem todas as vantagens dos métodos de Michael e Anth0, mas funciona para todos os UIControls, não apenas para UITextFields. Também funciona perfeitamente com o Interface Builder e os storyboards.

Aplicativo de origem e exemplo: repositório GitHub para UIControlsWithTabbing

Uso:

- (BOOL)textFieldShouldReturn:(UITextField *)textField
{
    [textField transferFirstResponderToNextControl];
    return NO;
}

Cabeçalho:

//
// UIControl+NextControl.h
// UIControlsWithTabbing
//

#import <UIKit/UIKit.h>

@interface UIControl (NextControl)

@property (nonatomic, weak) IBOutlet UIControl *nextControl;

- (BOOL)transferFirstResponderToNextControl;

@end

Implementação:

#import "UIControl+NextControl.h"
#import <objc/runtime.h>

static char defaultHashKey;

@implementation UIControl (NextControl)

- (UIControl *)nextControl
{
    return objc_getAssociatedObject(self, &defaultHashKey);
}

- (void)setNextControl:(UIControl *)nextControl
{
    objc_setAssociatedObject(self, &defaultHashKey, nextControl, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (BOOL)transferFirstResponderToNextControl
{
    if (self.nextControl)
    {
        [self.nextControl becomeFirstResponder];

        return YES;
    }

    [self resignFirstResponder];

    return NO;
}

@end

Eu tentei muitos códigos e, finalmente, isso funcionou para mim no Swift 3.0 mais recente [março de 2017]

A ViewControllerclasse deve ser herdada UITextFieldDelegatepara fazer esse código funcionar.

class ViewController: UIViewController,UITextFieldDelegate  

Adicione o campo Texto com o número de etiqueta apropriada e esse número de etiqueta é usado para levar o controle ao campo de texto apropriado com base no número de etiqueta incremental atribuído a ele.

override func viewDidLoad() {
    userNameTextField.delegate = self
    userNameTextField.tag = 0
    userNameTextField.returnKeyType = UIReturnKeyType.next
    passwordTextField.delegate = self
    passwordTextField.tag = 1
    passwordTextField.returnKeyType = UIReturnKeyType.go
}

No código acima, o returnKeyType = UIReturnKeyType.nextwhere fará com que o teclado volte a ser exibido, pois Nextvocê também tem outras opções, Join/Goetc., com base no seu aplicativo, altere os valores.

Este textFieldShouldReturné um método controlado por UITextFieldDelegate e aqui temos a próxima seleção de campo com base no incremento do valor do Tag

func textFieldShouldReturn(_ textField: UITextField) -> Bool {
    if let nextField = textField.superview?.viewWithTag(textField.tag + 1) as? UITextField {
        nextField.becomeFirstResponder()
    } else {
        textField.resignFirstResponder()
        return true;
    }
    return false
 }

Depois de sair de um campo de texto, você chama [otherTextField becomeFirstResponder] e o próximo campo fica em foco.

Na verdade, esse pode ser um problema complicado, pois muitas vezes você também deseja rolar a tela ou ajustar a posição do campo de texto para facilitar a visualização ao editar. Apenas faça muitos testes para entrar e sair dos campos de texto de maneiras diferentes e também para sair mais cedo (sempre dê ao usuário a opção de descartar o teclado em vez de ir para o próximo campo, geralmente com "Concluído" em a barra de navegação)

 -(BOOL)textFieldShouldReturn:(UITextField *)textField
{
   [[self.view viewWithTag:textField.tag+1] becomeFirstResponder];
   return YES;
}

Um método muito fácil de descartar o teclado quando o botão 'Concluído' é pressionado é:

Crie uma nova IBAction no cabeçalho

- (IBAction)textFieldDoneEditing:(id)sender;

No arquivo de implementação (arquivo .m), adicione o seguinte método:

- (IBAction)textFieldDoneEditing:(id)sender 
{ 
  [sender resignFirstResponder];
}

Então, quando você vincular o IBAction ao campo de texto - vincule ao evento 'Terminou na saída'.

Primeiro defina a tecla de retorno do teclado no xib, caso contrário, você poderá escrever o código em viewdidload:

passWord.returnKeyType = UIReturnKeyNext;

-(BOOL)textFieldShouldReturn:(UITextField *)textField
{
    if(textField == eMail) {
        [textField resignFirstResponder];
        [userName becomeFirstResponder];
    }
    if (textField==userName) {
        [textField resignFirstResponder];
        [passWord becomeFirstResponder];
    }
    if (textField==passWord) {
        [textField resignFirstResponder];
        [country becomeFirstResponder];
    }
    if (textField==country) {
        [textField resignFirstResponder];
    }
    return YES;
}

Estou surpreso com quantas respostas aqui não conseguem entender um conceito simples: navegar pelos controles no seu aplicativo não é algo que as próprias visualizações devem fazer. É o controlador é decidir qual controle deve ser o próximo responsável pela resposta.

Além disso, a maioria das respostas se aplica apenas à navegação para frente, mas os usuários também podem querer retroceder.

Então aqui está o que eu criei. Seu formulário deve ser gerenciado por um controlador de exibição, e os controladores de exibição fazem parte da cadeia de respostas. Portanto, você está perfeitamente livre para implementar os seguintes métodos:

#pragma mark - Key Commands

- (NSArray *)keyCommands
{
    static NSArray *commands;

    static dispatch_once_t once;
    dispatch_once(&once, ^{
        UIKeyCommand *const forward = [UIKeyCommand keyCommandWithInput:@"\t" modifierFlags:0 action:@selector(tabForward:)];
        UIKeyCommand *const backward = [UIKeyCommand keyCommandWithInput:@"\t" modifierFlags:UIKeyModifierShift action:@selector(tabBackward:)];

        commands = @[forward, backward];
    });

    return commands;
}

- (void)tabForward:(UIKeyCommand *)command
{
    NSArray *const controls = self.controls;
    UIResponder *firstResponder = nil;

    for (UIResponder *const responder in controls) {
        if (firstResponder != nil && responder.canBecomeFirstResponder) {
            [responder becomeFirstResponder]; return;
        }
        else if (responder.isFirstResponder) {
            firstResponder = responder;
        }
    }

    [controls.firstObject becomeFirstResponder];
}

- (void)tabBackward:(UIKeyCommand *)command
{
    NSArray *const controls = self.controls;
    UIResponder *firstResponder = nil;

    for (UIResponder *const responder in controls.reverseObjectEnumerator) {
        if (firstResponder != nil && responder.canBecomeFirstResponder) {
            [responder becomeFirstResponder]; return;
        }
        else if (responder.isFirstResponder) {
            firstResponder = responder;
        }
    }

    [controls.lastObject becomeFirstResponder];
}

Pode ser aplicada lógica adicional para rolar os respondedores fora da tela visíveis antes.

Outra vantagem dessa abordagem é que você não precisa subclassificar todos os tipos de controles que deseja exibir, UITextFieldmas pode gerenciar a lógica no nível do controlador, onde, sejamos honestos, é o lugar certo para fazer isso .

Eu adicionei à resposta do PeyloW caso você esteja procurando implementar uma funcionalidade de botão anterior / seguinte:

- (IBAction)moveThroughTextFields:(UIBarButtonItem *)sender 
{
    NSInteger nextTag;
    UITextView *currentTextField = [self.view findFirstResponderAndReturn];

    if (currentTextField != nil) {
        // I assigned tags to the buttons.  0 represent prev & 1 represents next
        if (sender.tag == 0) {
            nextTag = currentTextField.tag - 1;

        } else if (sender.tag == 1) {
            nextTag = currentTextField.tag + 1;
        }
    }
    // Try to find next responder
    UIResponder* nextResponder = [self.view viewWithTag:nextTag];
    if (nextResponder) {
        // Found next responder, so set it.
        // I added the resign here in case there's different keyboards in place.
        [currentTextField resignFirstResponder];
        [nextResponder becomeFirstResponder];
    } else {
        // Not found, so remove keyboard.
        [currentTextField resignFirstResponder];

    }
}

Onde você subclassifica o UIView assim:

@implementation UIView (FindAndReturnFirstResponder)
- (UITextView *)findFirstResponderAndReturn
{
    for (UITextView *subView in self.subviews) {
        if (subView.isFirstResponder){
            return subView;
        }
    }
    return nil;
}
@end

Olá a todos, por favor, veja este

- (void)nextPrevious:(id)sender
{

  UIView *responder = [self.view findFirstResponder];   

  if (nil == responder || ![responder isKindOfClass:[GroupTextField class]]) {
    return;
  }

  switch([(UISegmentedControl *)sender selectedSegmentIndex]) {
    case 0:
      // previous
      if (nil != ((GroupTextField *)responder).previousControl) {
        [((GroupTextField *)responder).previousControl becomeFirstResponder];
        DebugLog(@"currentControl: %i previousControl: %i",((GroupTextField *)responder).tag,((GroupTextField *)responder).previousControl.tag);
      }
      break;
    case 1:
      // next
      if (nil != ((GroupTextField *)responder).nextControl) {
        [((GroupTextField *)responder).nextControl becomeFirstResponder];
        DebugLog(@"currentControl: %i nextControl: %i",((GroupTextField *)responder).tag,((GroupTextField *)responder).nextControl.tag);
      }     
      break;    
  }
}

Tentei resolver esse problema usando uma abordagem mais sofisticada baseada na atribuição de cada célula (ou UITextField) em um UITableViewvalor de tag exclusivo que pode ser recuperado posteriormente: enable-next-uitextfield-in-uitableview-ios

Eu espero que isso ajude!

Acabei de criar um novo Pod ao lidar com esse material GNTextFieldsCollectionManager . Ele lida automaticamente com o próximo / último problema do textField e é muito fácil de usar:

[[GNTextFieldsCollectionManager alloc] initWithView:self.view];

Agarra todos os campos de texto classificados por aparecer na hierarquia de exibição (ou por tags), ou você pode especificar sua própria matriz de campos de texto.

Solução no Swift 3.1, depois de conectar seus campos de texto, IBOutlets defina seu delegado de campos de texto em viewDidLoad e navegue sua ação em textFieldShouldReturn

class YourViewController: UIViewController,UITextFieldDelegate {

        @IBOutlet weak var passwordTextField: UITextField!
        @IBOutlet weak var phoneTextField: UITextField!

        override func viewDidLoad() {
            super.viewDidLoad()
            self.passwordTextField.delegate = self
            self.phoneTextField.delegate = self
            // Set your return type
            self.phoneTextField.returnKeyType = .next
            self.passwordTextField.returnKeyType = .done
        }

        func textFieldShouldReturn(_ textField: UITextField) -> Bool{
            if textField == self.phoneTextField {
                self.passwordTextField.becomeFirstResponder()
            }else if textField == self.passwordTextField{
                // Call login api
                self.login()
            }
            return true
        }

    }

Se alguém quiser assim. Eu acho que este é o mais próximo dos requisitos solicitados em questão

Aqui está como eu implementei este

Adicione visualização acessória para cada campo de texto para o qual você deseja configurar, usando

func setAccessoryViewFor(textField : UITextField)    {
    let toolBar = UIToolbar()
    toolBar.barStyle = .default
    toolBar.isTranslucent = true
    toolBar.sizeToFit()

    // Adds the buttons

    // Add previousButton
    let prevButton = UIBarButtonItem(title: "<", style: .plain, target: self, action: #selector(previousPressed(sender:)))
    prevButton.tag = textField.tag
    if getPreviousResponderFor(tag: textField.tag) == nil {
        prevButton.isEnabled = false
    }

    // Add nextButton
    let nextButton = UIBarButtonItem(title: ">", style: .plain, target: self, action: #selector(nextPressed(sender:)))
    nextButton.tag = textField.tag
    if getNextResponderFor(tag: textField.tag) == nil {
        nextButton.title = "Done"
    }

    let spaceButton = UIBarButtonItem(barButtonSystemItem: .flexibleSpace, target: nil, action: nil)
    toolBar.setItems([prevButton,spaceButton,nextButton], animated: false)
    toolBar.isUserInteractionEnabled = true
    textField.inputAccessoryView = toolBar
}

Use as seguintes funções para lidar com torneiras

func nextPressed(sender : UIBarButtonItem) {
    if let nextResponder = getNextResponderFor(tag: sender.tag) {
        nextResponder.becomeFirstResponder()
    } else {
        self.view.endEditing(true)
    }

}

func previousPressed(sender : UIBarButtonItem) {
    if let previousResponder = getPreviousResponderFor(tag : sender.tag)  {
        previousResponder.becomeFirstResponder()
    }
}

func getNextResponderFor(tag : Int) -> UITextField? {
    return self.view.viewWithTag(tag + 1) as? UITextField
}

func getPreviousResponderFor(tag : Int) -> UITextField? {
    return self.view.viewWithTag(tag - 1) as? UITextField
}

Você precisará fornecer as tags textFields na sequência em que deseja que o botão próximo / anterior responda.

Prefiro:

@interface MyViewController : UIViewController
@property (nonatomic, retain) IBOutletCollection(UIView) NSArray *inputFields;
@end

No arquivo NIB, conecto os textFields na ordem desejada a esse array inputFields. Depois disso, faço um teste simples para o índice do UITextField que informa que o usuário tocou em retornar:

// for UITextField
-(BOOL)textFieldShouldReturn:(UITextField*)textField {
    NSUInteger index = [_inputFields indexOfObject:textField];
    index++;
    if (index < _inputFields.count) {
        UIView *v = [_inputFields objectAtIndex:index];
        [v becomeFirstResponder];
    }
    return NO;
}

// for UITextView
-(BOOL)textView:(UITextView*)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString*)text {
    if ([@"\n" isEqualToString:text]) {
        NSUInteger index = [_inputFields indexOfObject:textView];
        index++;
        if (index < _inputFields.count) {
            UIView *v = [_inputFields objectAtIndex:index];
            [v becomeFirstResponder];
        } else {
            [self.view endEditing:YES];
        }
        return NO;
    }
    return YES;
}

if (célula == nil)
{
    célula = [[alocação de UITableViewCell] initWithStyle: UITableViewCellStyleDefault reuseIdentifier: cellIdentifier];
    txt_Input = [[alocação de UITextField] initWithFrame: CGRectMake (0, 10, 150, 30)];
    txt_Input.tag = indexPath.row + 1;
    [self.array_Textfields addObject: txt_Input]; // Inicializa a matriz mutável em ViewDidLoad
}

- (BOOL) textFieldShouldReturn: (UITextField *) textField
{

    int tag = (int) textField.tag;
    UITextField * txt = [self.array_Textfields objectAtIndex: tag];
    [txt becomeFirstResponder];
    retornar SIM;
}

Eu tinha cerca de 10+ UITextField no meu storyboard e a maneira como habilitei a próxima funcionalidade foi criar uma matriz de UITextField e tornar o próximo UITextField o firstResponder. Aqui está o arquivo de implementação:

#import "RegistrationTableViewController.h"

@interface RegistrationTableViewController ()
@property (weak, nonatomic) IBOutlet UITextField *fullNameTextField;
@property (weak, nonatomic) IBOutlet UITextField *addressTextField;
@property (weak, nonatomic) IBOutlet UITextField *address2TextField;
@property (weak, nonatomic) IBOutlet UITextField *cityTextField;
@property (weak, nonatomic) IBOutlet UITextField *zipCodeTextField;
@property (weak, nonatomic) IBOutlet UITextField *urlTextField;
@property (weak, nonatomic) IBOutlet UITextField *usernameTextField;
@property (weak, nonatomic) IBOutlet UITextField *emailTextField;
@property (weak, nonatomic) IBOutlet UITextField *passwordTextField;
@property (weak, nonatomic) IBOutlet UITextField *confirmPWTextField;

@end
NSArray *uiTextFieldArray;
@implementation RegistrationTableViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"view did load");
    uiTextFieldArray = @[self.fullNameTextField,self.addressTextField,self.address2TextField,self.cityTextField,self.zipCodeTextField,self.urlTextField,self.usernameTextField,self.emailTextField,self.passwordTextField,self.confirmPWTextField];
    for(UITextField *myField in uiTextFieldArray){
        myField.delegate = self;
    }


}
-(BOOL)textFieldShouldReturn:(UITextField *)textField{
    long index = [uiTextFieldArray indexOfObject:textField];
    NSLog(@"%ld",index);
    if(index < (uiTextFieldArray.count - 1)){
        [uiTextFieldArray[++index] becomeFirstResponder];
    }else{
        [uiTextFieldArray[index] resignFirstResponder];
    }
    return YES;
}
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end

Isso funcionou para mim no Xamarin.iOS / Monotouch. Altere o botão do teclado para Avançar, passe o controle para o próximo UITextField e oculte o teclado após o último UITextField.

private void SetShouldReturnDelegates(IEnumerable<UIView> subViewsToScout )
{
  foreach (var item in subViewsToScout.Where(item => item.GetType() == typeof (UITextField)))
  {
    (item as UITextField).ReturnKeyType = UIReturnKeyType.Next;
    (item as UITextField).ShouldReturn += (textField) =>
    {
        nint nextTag = textField.Tag + 1;
        var nextResponder = textField.Superview.ViewWithTag(nextTag);
        if (null != nextResponder)
            nextResponder.BecomeFirstResponder();
        else
            textField.Superview.EndEditing(true); 
            //You could also use textField.ResignFirstResponder(); 

        return false; // We do not want UITextField to insert line-breaks.
    };
  }
}

Dentro do ViewDidLoad, você terá:

Se seus TextFields não tiverem um Tag, defina-o agora:

txtField1.Tag = 0;
txtField2.Tag = 1;
txtField3.Tag = 2;
//...

e apenas a ligação

SetShouldReturnDelegates(yourViewWithTxtFields.Subviews.ToList());
//If you are not sure of which view contains your fields you can also call it in a safer way:
SetShouldReturnDelegates(txtField1.Superview.Subviews.ToList());
//You can also reuse the same method with different containerViews in case your UITextField are under different views.

Esta é uma solução simples, rápida, sem uso de tags, sem truques de storyboard ...

Basta usar esta extensão:

extension UITextField{

    func nextTextFieldField() -> UITextField?{
        //field to return
        var returnField : UITextField?
        if self.superview != nil{
            //for each view in superview
            for (_, view) in self.superview!.subviews.enumerate(){
                //if subview is a text's field
                if view.isKindOfClass(UITextField){
                    //cast curent view as text field
                    let currentTextField = view as! UITextField
                    //if text field is after the current one
                    if currentTextField.frame.origin.y > self.frame.origin.y{
                        //if there is no text field to return already
                        if returnField == nil {
                            //set as default return
                            returnField = currentTextField
                        }
                            //else if this this less far than the other
                        else if currentTextField.frame.origin.y < returnField!.frame.origin.y{
                            //this is the field to return
                            returnField = currentTextField
                        }
                    }
                }
            }
        }
        //end of the mdethod
        return returnField
    }

}

E chame assim (por exemplo) com seu delegado do campo de texto:

func textFieldShouldReturn(textField: UITextField) -> Bool {
    textField.resignFirstResponder()
    textField.nextTextFieldField()?.becomeFirstResponder()
    return true
}

Uma maneira mais segura e direta, assumindo:

• os delegados do campo de texto estão definidos para o seu controlador de exibição
• todos os campos de texto são subviews da mesma view
• os campos de texto possuem tags na ordem em que você deseja progredir (por exemplo, textField2.tag = 2, textField3.tag = 3, etc.)
• a mudança para o próximo campo de texto ocorrerá quando você tocar no botão de retorno no teclado (você pode alterar para próximo , pronto etc.)
• você deseja que o teclado seja descartado após o último campo de texto

Swift 4.1:

extension ViewController: UITextFieldDelegate {
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        let nextTag = textField.tag + 1
        guard let nextTextField = textField.superview?.viewWithTag(nextTag) else {
            textField.resignFirstResponder()
            return false
        }

    nextTextField.becomeFirstResponder()

    return false

    }
}

em textFieldShouldReturn, verifique se o campo de texto em que você está atualmente não é o último quando clica em Avançar e se ele não dispensa o teclado.

Este é um post antigo, mas tem um alto page rank, por isso vou falar com minha solução.

Eu tive um problema semelhante e acabei criando uma subclasse de UIToolbarpara gerenciar a funcionalidade próxima / anterior / concluída em uma tabela dinâmica.Ver com seções: https://github.com/jday001/DataEntryToolbar

Você define a barra de ferramentas como inputAccessoryView dos seus campos de texto e os adiciona ao seu dicionário. Isso permite que você alterne entre eles para frente e para trás, mesmo com conteúdo dinâmico. Existem métodos delegados se você deseja acionar sua própria funcionalidade quando a navegação textField acontece, mas você não precisa lidar com o gerenciamento de nenhuma tag ou status de respondedor.

Existem trechos de código e um aplicativo de exemplo no link do GitHub para ajudar nos detalhes da implementação. Você precisará de seu próprio modelo de dados para acompanhar os valores dentro dos campos.

Sem usar tags e sem adicionar uma propriedade para nextField / nextTextField, você pode tentar emular TAB, onde "testInput" é o seu campo ativo atual:

if ([textInput isFirstResponder])
    [textInput.superview.subviews enumerateObjectsAtIndexes:
     [NSIndexSet indexSetWithIndexesInRange:
      NSMakeRange([textInput.superview.subviews indexOfObject:textInput]+1,
                  [textInput.superview.subviews count]-[textInput.superview.subviews indexOfObject:textInput]-1)]
                                                    options:0 usingBlock:^(UIView *obj, NSUInteger idx, BOOL *stop) {
                                                        *stop = !obj.hidden && [obj becomeFirstResponder];
                                                    }];
if ([textInput isFirstResponder])
    [textInput.superview.subviews enumerateObjectsAtIndexes:
     [NSIndexSet indexSetWithIndexesInRange:
      NSMakeRange(0,
                  [textInput.superview.subviews indexOfObject:textInput])]
                                                    options:0 usingBlock:^(UIView *obj, NSUInteger idx, BOOL *stop) {
                                                        *stop = !obj.hidden && [obj becomeFirstResponder];
                                                    }];

Estou usando a resposta de Michael G. Emmons há cerca de um ano, funciona muito bem. Recentemente, notei que chamar resignFirstResponder e, em seguida, tornar-seFirstResponder imediatamente pode causar uma falha no teclado, desaparecendo e aparecendo imediatamente. Alterei a versão dele ligeiramente para pular o resignFirstResponder se o nextField estiver disponível.

- (BOOL) textFieldShouldReturn: (UITextField *) textField
{ 

    if ([textField isKindOfClass: [NRTextField class]])
    {
        NRTextField * nText = (NRTextField *) textField;
        if ([nText nextField]! = nil) {
            dispatch_async (dispatch_get_main_queue (),
                           ^ {[[nText nextField] becomeFirstResponder]; });

        }
        outro{
            [textField resignFirstResponder];
        }
    }
    outro{
        [textField resignFirstResponder];
    }

    return true;

}