Qual é a maneira mais robusta de forçar um UIView a redesenhar?

Eu tenho um UITableView com uma lista de itens. Selecionar um item empurra um viewController que então prossegue para fazer o seguinte. do método viewDidLoad eu disparo um URLRequest para dados que são exigidos por uma das minhas subvisualizações - uma subclasse UIView com drawRect substituído. Quando os dados chegam da nuvem, começo a construir minha hierarquia de visualizações. a subclasse em questão passa os dados e seu método drawRect agora tem tudo o que precisa para renderizar.

Mas.

Porque eu não chamo drawRect explicitamente - Cocoa-Touch lida com isso - não tenho como informar ao Cocoa-Touch que eu realmente quero que esta subclasse UIView renderize. Quando? Agora seria bom!

Eu tentei [myView setNeedsDisplay]. Isso meio que funciona às vezes. Muito irregular.

Estou lutando com isso por horas e horas. Alguém poderia me fornecer uma abordagem sólida e garantida para forçar uma re-renderização do UIView.

Aqui está o snippet de código que alimenta os dados da visualização:

// Create the subview
self.chromosomeBlockView = [[[ChromosomeBlockView alloc] initWithFrame:frame] autorelease];

// Set some properties
self.chromosomeBlockView.sequenceString     = self.sequenceString;
self.chromosomeBlockView.nucleotideBases    = self.nucleotideLettersDictionary;

// Insert the view in the view hierarchy
[self.containerView          addSubview:self.chromosomeBlockView];
[self.containerView bringSubviewToFront:self.chromosomeBlockView];

// A vain attempt to convince Cocoa-Touch that this view is worthy of being displayed ;-)
[self.chromosomeBlockView setNeedsDisplay];

Saúde, Doug

A maneira garantida e sólida de forçar uma UIViewnova renderização é [myView setNeedsDisplay]. Se você está tendo problemas com isso, provavelmente está tendo um destes problemas:

• Você está chamando antes de realmente ter os dados ou -drawRect:está armazenando algo em excesso no cache.

• Você está esperando que a visualização seja desenhada no momento em que chamar esse método. Intencionalmente, não há como exigir "desenhar agora neste exato segundo" usando o sistema de desenho Cocoa. Isso interromperia todo o sistema de composição de visualização, prejudicaria o desempenho e provavelmente criaria todos os tipos de artefatos. Só existem maneiras de dizer "isso precisa ser desenhado no próximo ciclo de desenho".

Se você precisa de "um pouco de lógica, desenhe, um pouco mais de lógica", então você precisa colocar "um pouco mais de lógica" em um método separado e invocá-lo usando -performSelector:withObject:afterDelay:com um atraso de 0. Isso colocará "um pouco mais de lógica" depois o próximo ciclo de sorteio. Consulte esta pergunta para obter um exemplo desse tipo de código e um caso em que ele pode ser necessário (embora geralmente seja melhor procurar outras soluções, se possível, pois isso complica o código).

Se você acha que as coisas não estão sendo desenhadas, coloque um ponto de interrupção -drawRect:e veja quando você será chamado. Se você estiver chamando -setNeedsDisplay, mas -drawRect:não for chamado no próximo loop de evento, explore sua hierarquia de visualizações e certifique-se de que não está tentando ser mais esperto que está em algum lugar. O excesso de esperteza é a causa número 1 de um desenho ruim na minha experiência. Quando você acha que sabe como enganar o sistema para fazer o que você quer, geralmente consegue que ele faça exatamente o que não quer.

Eu tive um problema com um grande atraso entre chamar setNeedsDisplay e drawRect: (5 segundos). Acontece que eu chamei setNeedsDisplay em um thread diferente do thread principal. Depois de mover esta chamada para o thread principal, o atraso foi embora.

Espero que isso ajude.

A maneira garantida de devolução do dinheiro e sólido de concreto armado de forçar uma visualização a desenhar de forma síncrona (antes de retornar ao código de chamada) é configurar as CALayerinterações de com sua UIViewsubclasse.

Em sua subclasse UIView, crie um displayNow()método que diga à camada para " definir o curso para exibição " e " torná-lo assim ":

_Rápido

/// Redraws the view's contents immediately.
/// Serves the same purpose as the display method in GLKView.
public func displayNow()
{
    let layer = self.layer
    layer.setNeedsDisplay()
    layer.displayIfNeeded()
}

_Objective-C

/// Redraws the view's contents immediately.
/// Serves the same purpose as the display method in GLKView.
- (void)displayNow
{
    CALayer *layer = self.layer;
    [layer setNeedsDisplay];
    [layer displayIfNeeded];
}

Implemente também um draw(_: CALayer, in: CGContext)método que chamará seu método de desenho privado / interno (que funciona já que todo UIViewé um CALayerDelegate) :

_Rápido

/// Called by our CALayer when it wants us to draw
///     (in compliance with the CALayerDelegate protocol).
override func draw(_ layer: CALayer, in context: CGContext)
{
    UIGraphicsPushContext(context)
    internalDraw(self.bounds)
    UIGraphicsPopContext()
}

_Objective-C

/// Called by our CALayer when it wants us to draw
///     (in compliance with the CALayerDelegate protocol).
- (void)drawLayer:(CALayer *)layer inContext:(CGContextRef)context
{
    UIGraphicsPushContext(context);
    [self internalDrawWithRect:self.bounds];
    UIGraphicsPopContext();
}

E crie seu internalDraw(_: CGRect)método personalizado , junto com a prova de falhas draw(_: CGRect):

_Rápido

/// Internal drawing method; naming's up to you.
func internalDraw(_ rect: CGRect)
{
    // @FILLIN: Custom drawing code goes here.
    //  (Use `UIGraphicsGetCurrentContext()` where necessary.)
}

/// For compatibility, if something besides our display method asks for draw.
override func draw(_ rect: CGRect) {
    internalDraw(rect)
}

_Objective-C

/// Internal drawing method; naming's up to you.
- (void)internalDrawWithRect:(CGRect)rect
{
    // @FILLIN: Custom drawing code goes here.
    //  (Use `UIGraphicsGetCurrentContext()` where necessary.)
}

/// For compatibility, if something besides our display method asks for draw.
- (void)drawRect:(CGRect)rect {
    [self internalDrawWithRect:rect];
}

E agora apenas chame myView.displayNow()sempre que você realmente precisar para desenhar (como em um CADisplayLinkretorno de chamada) . Nosso displayNow()método dirá o CALayerpara displayIfNeeded(), que irá chamar de volta sincronizadamente o nosso draw(_:,in:)e desenhar internalDraw(_:), atualizando o visual com o que é desenhado no contexto antes de prosseguir.

Essa abordagem é semelhante à de @RobNapier acima, mas tem a vantagem de chamar displayIfNeeded()além de setNeedsDisplay(), o que a torna síncrona.

Isso é possível porque CALayers expõe mais funcionalidade de desenho do que UIViews - as camadas são de nível inferior do que as vistas e são projetadas explicitamente para o propósito de desenho altamente configurável dentro do layout e (como muitas coisas no Cocoa) são projetadas para serem usadas de forma flexível ( como uma classe pai, ou como um delegador, ou como uma ponte para outros sistemas de desenho, ou apenas por conta própria). O uso adequado do CALayerDelegateprotocolo torna tudo isso possível.

Mais informações sobre a configurabilidade de CALayers podem ser encontradas na seção Setting Up Layer Objects do Core Animation Programming Guide .

Eu tive o mesmo problema e todas as soluções do SO ou do Google não funcionaram para mim. Normalmente, setNeedsDisplayfunciona, mas quando não ...
Eu tentei chamar setNeedsDisplaydo modo de exibição de todas as maneiras possíveis de todos os threads possíveis e outras coisas - ainda sem sucesso. Nós sabemos, como Rob disse, que

"isso precisa ser desenhado no próximo ciclo de sorteio."

Mas por alguma razão não iria desenhar desta vez. E a única solução que encontrei é chamá-lo manualmente depois de algum tempo, para deixar passar qualquer coisa que bloqueie o empate, assim:

dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, 
                                        (int64_t)(0.005 * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void) {
    [viewToRefresh setNeedsDisplay];
});

É uma boa solução se você não precisa que a visualização seja redesenhada com frequência. Caso contrário, se você estiver fazendo alguma coisa de movimento (ação), geralmente não há problemas em apenas pagar setNeedsDisplay.

Espero que ajude alguém que está perdido ali, como eu.

Bem, eu sei que isso pode ser uma grande mudança ou até mesmo não adequado para o seu projeto, mas você considerou não realizar o push até que já tenha os dados ? Dessa forma, você só precisa desenhar a vista uma vez e a experiência do usuário também será melhor - o push já estará carregado.

A maneira de fazer isso é UITableView didSelectRowAtIndexPathsolicitando os dados de maneira assíncrona. Depois de receber a resposta, você executa manualmente a segue e passa os dados para seu viewController no prepareForSegue. Enquanto isso, você pode querer mostrar algum indicador de atividade, para um indicador de carregamento simples, verifique https://github.com/jdg/MBProgressHUD