Estou escrevendo um aplicativo e preciso alterar a exibição se o usuário estiver olhando para o aplicativo enquanto estiver falando ao telefone.

Eu implementei o seguinte método:

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    NSLog(@"viewWillAppear:");
    _sv.frame = CGRectMake(0.0, 0.0, 320.0, self.view.bounds.size.height);
}

Mas não está sendo chamado quando o aplicativo retorna ao primeiro plano.

Eu sei que posso implementar:

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(statusBarFrameChanged:) name:UIApplicationDidChangeStatusBarFrameNotification object:nil];

mas eu não quero fazer isso. Prefiro colocar todas as minhas informações de layout no método viewWillAppear: e deixar que isso lide com todos os cenários possíveis.

Eu até tentei chamar viewWillAppear: from applicationWillEnterForeground :, mas não consigo identificar qual é o controlador de exibição atual naquele momento.

Alguém sabe a maneira correta de lidar com isso? Tenho certeza de que estou perdendo uma solução óbvia.

O método viewWillAppeardeve ser adotado no contexto do que está acontecendo em seu próprio aplicativo, e não no contexto de seu aplicativo ser colocado em primeiro plano quando você voltar para outro aplicativo.

Em outras palavras, se alguém olhar para outro aplicativo ou receber uma ligação telefônica, voltará para o seu aplicativo que estava em segundo plano, o seu UIViewController que já estava visível quando você saiu do aplicativo 'não se importa', por assim dizer - no que diz respeito, nunca desapareceu e ainda é visível - e assim viewWillAppearnão é chamado.

Eu recomendo não ligar para viewWillAppearvocê mesmo - ele tem um significado específico que você não deve subverter! Uma refatoração que você pode fazer para obter o mesmo efeito pode ser a seguinte:

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    [self doMyLayoutStuff:self];
}

- (void)doMyLayoutStuff:(id)sender {
    // stuff
}

Em seguida, você também aciona a doMyLayoutStuffpartir da notificação apropriada:

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(doMyLayoutStuff:) name:UIApplicationDidChangeStatusBarFrameNotification object:self];

Não existe uma maneira imediata de saber qual é o UIViewController 'atual' a propósito. Mas você pode encontrar maneiras de contornar isso, por exemplo, existem métodos delegados do UINavigationController para descobrir quando um UIViewController é apresentado nele. Você pode usar isso para rastrear o UIViewController mais recente que foi apresentado.

Atualizar

Se você criar layouts de interface do usuário com as máscaras de redimensionamento apropriadas nos vários bits, às vezes nem precisará lidar com o layout 'manual' da sua interface do usuário - ele é tratado apenas ...

Rápido

Resposta curta

Use um NotificationCenterobservador em vez de viewWillAppear.

override func viewDidLoad() {
    super.viewDidLoad()

    // set observer for UIApplication.willEnterForegroundNotification
    NotificationCenter.default.addObserver(self, selector: #selector(willEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)

}

// my selector that was defined above
@objc func willEnterForeground() {
    // do stuff
}

Resposta longa

Para descobrir quando um aplicativo volta dos bastidores, use um NotificationCenterobservador em vez de viewWillAppear. Aqui está um projeto de amostra que mostra quais eventos acontecem quando. (Esta é uma adaptação desta resposta do Objective-C .)

import UIKit
class ViewController: UIViewController {

    // MARK: - Overrides

    override func viewDidLoad() {
        super.viewDidLoad()
        print("view did load")

        // add notification observers
        NotificationCenter.default.addObserver(self, selector: #selector(didBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(willEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)

    }

    override func viewWillAppear(_ animated: Bool) {
        print("view will appear")
    }

    override func viewDidAppear(_ animated: Bool) {
        print("view did appear")
    }

    // MARK: - Notification oberserver methods

    @objc func didBecomeActive() {
        print("did become active")
    }

    @objc func willEnterForeground() {
        print("will enter foreground")
    }

}

Ao iniciar o aplicativo, a ordem de saída é:

view did load
view will appear
did become active
view did appear

Depois de pressionar o botão home e, em seguida, trazer o aplicativo de volta ao primeiro plano, a ordem de saída é:

will enter foreground
did become active 

Portanto, se você estava originalmente tentando usar viewWillAppear, UIApplication.willEnterForegroundNotificationprovavelmente é o que deseja.

Nota

A partir do iOS 9 e posterior, você não precisa remover o observador. A documentação declara:

Se seu aplicativo atingir o iOS 9.0 e posterior ou o macOS 10.11 e posterior, não será necessário cancelar o registro de um observador no deallocmétodo.

Use o Notification Center no viewDidLoad:método do seu ViewController para chamar um método e, a partir daí, faça o que você deveria fazer no seu viewWillAppear:método. Ligar viewWillAppear:diretamente não é uma boa opção.

- (void)viewDidLoad
{
    [super viewDidLoad];
    NSLog(@"view did load");

    [[NSNotificationCenter defaultCenter] addObserver:self 
        selector:@selector(applicationIsActive:) 
        name:UIApplicationDidBecomeActiveNotification 
        object:nil];

    [[NSNotificationCenter defaultCenter] addObserver:self 
        selector:@selector(applicationEnteredForeground:) 
        name:UIApplicationWillEnterForegroundNotification
        object:nil];
}

- (void)applicationIsActive:(NSNotification *)notification {
    NSLog(@"Application Did Become Active");
}

- (void)applicationEnteredForeground:(NSNotification *)notification {
    NSLog(@"Application Entered Foreground");
}

viewWillAppear:animated:, um dos métodos mais confusos nos SDKs do iOS, na minha opinião, nunca é invocado em tal situação, ou seja, na alternância de aplicativos. Esse método é chamado apenas de acordo com a relação entre a visualização do controlador de visualização e a janela do aplicativo , ou seja, a mensagem é enviada para um controlador de visualização apenas se sua visualização aparecer na janela do aplicativo e não na tela.

Quando seu aplicativo fica em segundo plano, obviamente as vistas mais altas da janela do aplicativo não são mais visíveis para o usuário. Na perspectiva da janela do aplicativo, no entanto, elas ainda são as vistas superiores e, portanto, não desapareceram da janela. Em vez disso, essas visualizações desapareceram porque a janela do aplicativo desapareceu. Eles não desapareceram porque desapareceram da janela.

Portanto, quando o usuário volta para o seu aplicativo, ele obviamente aparece na tela, porque a janela aparece novamente. Mas da perspectiva da janela, eles não desapareceram. Portanto, os controladores de exibição nunca recebem a viewWillAppear:animatedmensagem.

Swift 4.2 / 5

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(self, selector: #selector(willEnterForeground),
                                           name: Notification.Name.UIApplicationWillEnterForeground,
                                           object: nil)
}

@objc func willEnterForeground() {
   // do what's needed
}

Apenas tentando facilitar o máximo possível, veja o código abaixo:

- (void)viewDidLoad
{
   [self appWillEnterForeground]; //register For Application Will enterForeground
}


- (id)appWillEnterForeground{ //Application will enter foreground.

    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(allFunctions)
                                                 name:UIApplicationWillEnterForegroundNotification
                                               object:nil];
    return self;
}


-(void) allFunctions{ //call any functions that need to be run when application will enter foreground 
    NSLog(@"calling all functions...application just came back from foreground");


}