Desativando animações implícitas em - [CALayer setNeedsDisplayInRect:]

Eu tenho uma camada com algum código de desenho complexo em seu método -drawInContext:. Estou tentando minimizar a quantidade de desenho que preciso fazer, portanto, estou usando -setNeedsDisplayInRect: para atualizar apenas as partes alteradas. Isso está funcionando esplendidamente. No entanto, quando o sistema gráfico atualiza minha camada, ele está mudando da imagem antiga para a nova imagem usando um cross-fade. Eu gostaria que mudasse instantaneamente.

Eu tentei usar o CATransaction para desativar ações e definir a duração como zero, e nenhum trabalho. Aqui está o código que estou usando:

[CATransaction begin];
[CATransaction setDisableActions: YES];
[self setNeedsDisplayInRect: rect];
[CATransaction commit];

Existe um método diferente no CATransaction que eu deveria usar (também tentei -setValue: forKey: with kCATransactionDisableActions, mesmo resultado).

Você pode fazer isso definindo o dicionário de ações na camada para retornar [NSNull null]como uma animação para a chave apropriada. Por exemplo, eu uso

NSDictionary *newActions = @{
    @"onOrderIn": [NSNull null],
    @"onOrderOut": [NSNull null],
    @"sublayers": [NSNull null],
    @"contents": [NSNull null],
    @"bounds": [NSNull null]
};

layer.actions = newActions;

para desativar as animações de desvanecimento / desbotamento na inserção ou alteração de subcamadas em uma das minhas camadas, bem como alterações no tamanho e no conteúdo da camada. Acredito que a contentschave é a que você está procurando para evitar o crossfade no desenho atualizado.

Versão rápida:

let newActions = [
        "onOrderIn": NSNull(),
        "onOrderOut": NSNull(),
        "sublayers": NSNull(),
        "contents": NSNull(),
        "bounds": NSNull(),
    ]

Além disso:

[CATransaction begin];
[CATransaction setValue:(id)kCFBooleanTrue forKey:kCATransactionDisableActions];

//foo

[CATransaction commit];

Quando você altera a propriedade de uma camada, a CA geralmente cria um objeto de transação implícito para animar a alteração. Se você não deseja animar a alteração, pode desativar animações implícitas criando uma transação explícita e configurando sua propriedade kCATransactionDisableActions como true .

Objetivo-C

[CATransaction begin];
[CATransaction setValue:(id)kCFBooleanTrue forKey:kCATransactionDisableActions];
// change properties here without animation
[CATransaction commit];

Rápido

CATransaction.begin()
CATransaction.setValue(kCFBooleanTrue, forKey: kCATransactionDisableActions)
// change properties here without animation
CATransaction.commit()

Além da resposta de Brad Larson : para camadas personalizadas (criadas por você), você pode usar a delegação em vez de modificar o actionsdicionário da camada . Essa abordagem é mais dinâmica e pode ter melhor desempenho. E permite desabilitar todas as animações implícitas sem precisar listar todas as chaves animáveis.

Infelizmente, é impossível usar UIViews como delegados de camadas personalizadas, porque cada UIViewum já é um delegado de sua própria camada. Mas você pode usar uma classe auxiliar simples como esta:

@interface MyLayerDelegate : NSObject
    @property (nonatomic, assign) BOOL disableImplicitAnimations;
@end

@implementation MyLayerDelegate

- (id<CAAction>)actionForLayer:(CALayer *)layer forKey:(NSString *)event
{
    if (self.disableImplicitAnimations)
         return (id)[NSNull null]; // disable all implicit animations
    else return nil; // allow implicit animations

    // you can also test specific key names; for example, to disable bounds animation:
    // if ([event isEqualToString:@"bounds"]) return (id)[NSNull null];
}

@end

Uso (dentro da vista):

MyLayerDelegate *delegate = [[MyLayerDelegate alloc] init];

// assign to a strong property, because CALayer's "delegate" property is weak
self.myLayerDelegate = delegate;

self.myLayer = [CALayer layer];
self.myLayer.delegate = delegate;

// ...

self.myLayerDelegate.disableImplicitAnimations = YES;
self.myLayer.position = (CGPoint){.x = 10, .y = 42}; // will not animate

// ...

self.myLayerDelegate.disableImplicitAnimations = NO;
self.myLayer.position = (CGPoint){.x = 0, .y = 0}; // will animate

Às vezes, é conveniente ter o controlador do view como um representante das subcamadas personalizadas do view; Nesse caso, não há necessidade de uma classe auxiliar, você pode implementar o actionForLayer:forKey:método dentro do controlador.

Nota importante: não tente modificar o delegado da UIViewcamada subjacente (por exemplo, para ativar animações implícitas) - coisas ruins acontecerão :)

Nota: se você deseja animar (e não desativar a animação para) redesenhos de camadas, é inútil colocar uma [CALayer setNeedsDisplayInRect:]chamada dentro de a CATransaction, porque o redesenho real pode (e provavelmente ocorrerá) algumas vezes mais tarde. A boa abordagem é usar propriedades personalizadas, conforme descrito nesta resposta .

Aqui está uma solução mais eficiente, semelhante à resposta aceita, mas para Swift . Em alguns casos, será melhor do que criar uma transação toda vez que você modificar o valor, o que é uma preocupação de desempenho, como outros já mencionaram, por exemplo, casos de uso comuns de arrastar a posição da camada a 60fps.

// Disable implicit position animation.
layer.actions = ["position": NSNull()]      

Consulte os documentos da apple para saber como as ações da camada são resolvidas . A implementação do delegado pularia mais um nível na cascata, mas, no meu caso, isso era muito confuso devido à advertência de que o delegado precisava ser definido para o UIView associado .

Editar: atualizado graças ao comentarista apontando que NSNullestá em conformidade CAAction.

Com base na resposta de Sam e nas dificuldades de Simon ... adicione a referência de delegado depois de criar o CSShapeLayer:

CAShapeLayer *myLayer = [CAShapeLayer layer];
myLayer.delegate = self; // <- set delegate here, it's magic.

... em outro lugar no arquivo "m" ...

Essencialmente o mesmo que o de Sam, sem a capacidade de alternar através do arranjo variável personalizado "disableImplicitAnimations". Mais uma abordagem "hard-wire".

- (id<CAAction>)actionForLayer:(CALayer *)layer forKey:(NSString *)event {

    // disable all implicit animations
    return (id)[NSNull null];

    // allow implicit animations
    // return nil;

    // you can also test specific key names; for example, to disable bounds animation:
    // if ([event isEqualToString:@"bounds"]) return (id)[NSNull null];

}

Na verdade, não encontrei nenhuma das respostas certas. O método que resolve o problema para mim foi o seguinte:

- (id<CAAction>)actionForKey:(NSString *)event {   
    return nil;   
}

Em seguida, você pode qualquer lógica nele, para desativar uma animação específica, mas como eu queria removê-las, retornei nulo.

Para desativar animações de camada implícitas no Swift

CATransaction.setDisableActions(true)

Descobriu um método mais simples para desativar a ação dentro de um CATransactionque chama internamente setValue:forKey:a kCATransactionDisableActionschave:

[CATransaction setDisableActions:YES];

Rápido:

CATransaction.setDisableActions(true)

Adicione isso à sua classe personalizada na qual você está implementando o método -drawRect (). Faça alterações no código para atender às suas necessidades, para mim, a 'opacidade' fez o truque para interromper a animação de desbotamento.

-(id<CAAction>) actionForLayer:(CALayer *)layer forKey:(NSString *)key
{
    NSLog(@"key: %@", key);
    if([key isEqualToString:@"opacity"])
    {
        return (id<CAAction>)[NSNull null];
    }

    return [super actionForLayer:layer forKey:key];
}

Se você precisar de uma correção muito rápida (mas reconhecidamente hacky), pode valer a pena fazer (Swift):

let layer = CALayer()

// set other properties
// ...

layer.speed = 999

Atualizado para agilizar e desabilitar apenas uma animação de propriedade implícita no iOS, não no MacOS

// Disable the implicit animation for changes to position
override open class func defaultAction(forKey event: String) -> CAAction? {
    if event == #keyPath(position) {
        return NSNull()
    }
    return super.defaultAction(forKey: event)
}

Outro exemplo, neste caso, eliminando duas animações implícitas.

class RepairedGradientLayer: CAGradientLayer {

    // Totally ELIMINATE idiotic implicit animations, in this example when
    // we hide or move the gradient layer

    override open class func defaultAction(forKey event: String) -> CAAction? {
        if event == #keyPath(position) {
            return NSNull()
        }
        if event == #keyPath(isHidden) {
            return NSNull()
        }
        return super.defaultAction(forKey: event)
    }
}

No iOS 7, existe um método de conveniência que faz exatamente isso:

[UIView performWithoutAnimation:^{
    // apply changes
}];

Para desativar a animação irritante (embaçada) ao alterar a propriedade de seqüência de caracteres de um CATextLayer, você pode fazer isso:

class CANullAction: CAAction {
    private static let CA_ANIMATION_CONTENTS = "contents"

    @objc
    func runActionForKey(event: String, object anObject: AnyObject, arguments dict: [NSObject : AnyObject]?) {
        // Do nothing.
    }
}

e use-o assim (não esqueça de configurar seu CATextLayer corretamente, por exemplo, a fonte correta, etc.):

caTextLayer.actions = [CANullAction.CA_ANIMATION_CONTENTS: CANullAction()]

Você pode ver minha configuração completa do CATextLayer aqui:

private let systemFont16 = UIFont.systemFontOfSize(16.0)

caTextLayer = CATextLayer()
caTextLayer.foregroundColor = UIColor.blackColor().CGColor
caTextLayer.font = CGFontCreateWithFontName(systemFont16.fontName)
caTextLayer.fontSize = systemFont16.pointSize
caTextLayer.alignmentMode = kCAAlignmentCenter
caTextLayer.drawsAsynchronously = false
caTextLayer.actions = [CANullAction.CA_ANIMATION_CONTENTS: CANullAction()]
caTextLayer.contentsScale = UIScreen.mainScreen().scale
caTextLayer.frame = CGRectMake(playbackTimeImage.layer.bounds.origin.x, ((playbackTimeImage.layer.bounds.height - playbackTimeLayer.fontSize) / 2), playbackTimeImage.layer.bounds.width, playbackTimeLayer.fontSize * 1.2)

uiImageTarget.layer.addSublayer(caTextLayer)
caTextLayer.string = "The text you want to display"

Agora você pode atualizar o caTextLayer.string o quanto quiser =)

Inspirado por isso e por esta resposta.

Tente isso.

let layer = CALayer()
layer.delegate = hoo // Same lifecycle UIView instance.

Aviso

Se você definir o delegado da instância do UITableView, às vezes ocorrerá uma falha (provavelmente o scrollview é o mais avançado chamado recursivamente).