Désactivation des animations implicites dans - [CALayer setNeedsDisplayInRect:]

J'ai une couche avec du code de dessin complexe dans sa méthode -drawInContext :. J'essaie de minimiser la quantité de dessin que je dois faire, donc j'utilise -setNeedsDisplayInRect: pour mettre à jour uniquement les pièces modifiées. Cela fonctionne à merveille. Cependant, lorsque le système graphique met à jour mon calque, il passe de l'ancienne à la nouvelle image en utilisant un fondu enchaîné. J'aimerais que cela change instantanément.

J'ai essayé d'utiliser CATransaction pour désactiver les actions et définir la durée sur zéro, et aucun des deux ne fonctionne. Voici le code que j'utilise:

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

Y a-t-il une méthode différente sur CATransaction que je devrais utiliser à la place (j'ai également essayé -setValue: forKey: avec kCATransactionDisableActions, même résultat).

Vous pouvez le faire en définissant le dictionnaire d'actions sur le calque pour qu'il renvoie [NSNull null]une animation pour la clé appropriée. Par exemple, j'utilise

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

layer.actions = newActions;

pour désactiver les animations de fondu entrant / sortant lors de l'insertion ou du changement de sous-couches dans l'un de mes calques, ainsi que des changements dans la taille et le contenu du calque. Je pense que la contentsclé est celle que vous recherchez pour éviter le fondu enchaîné sur le dessin mis à jour.

Version Swift:

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

Aussi:

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

//foo

[CATransaction commit];

Lorsque vous modifiez la propriété d'un calque, CA crée généralement un objet de transaction implicite pour animer la modification. Si vous ne souhaitez pas animer la modification, vous pouvez désactiver les animations implicites en créant une transaction explicite et en définissant sa propriété kCATransactionDisableActions sur true .

Objectif c

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

Rapide

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

En plus de la réponse de Brad Larson : pour les couches personnalisées (que vous avez créées), vous pouvez utiliser la délégation au lieu de modifier le actionsdictionnaire des couches . Cette approche est plus dynamique et peut être plus performante. Et il permet de désactiver toutes les animations implicites sans avoir à lister toutes les clés animables.

Malheureusement, il est impossible d'utiliser les UIViews comme délégués de couche personnalisés, car chacun UIViewest déjà un délégué de sa propre couche. Mais vous pouvez utiliser une classe d'assistance simple comme celle-ci:

@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

Utilisation (à l'intérieur de la vue):

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

Parfois, il est pratique d'avoir le contrôleur de vue comme délégué pour les sous-couches personnalisées de vue; dans ce cas, il n'y a pas besoin d'une classe d'assistance, vous pouvez implémenter la actionForLayer:forKey:méthode directement dans le contrôleur.

Note importante: n'essayez pas de modifier le délégué de UIViewla couche sous-jacente (par exemple pour activer des animations implicites) - de mauvaises choses vont arriver :)

Remarque: si vous souhaitez animer (et non désactiver l'animation pour) les redessins de calques, il est inutile de mettre un [CALayer setNeedsDisplayInRect:]appel à l'intérieur de a CATransaction, car un redessinage réel peut (et se produira probablement) parfois plus tard. La bonne approche consiste à utiliser des propriétés personnalisées, comme décrit dans cette réponse .

Voici une solution plus efficace, similaire à la réponse acceptée mais pour Swift . Dans certains cas, ce sera mieux que de créer une transaction à chaque fois que vous modifiez la valeur, ce qui est un problème de performance comme d'autres l'ont mentionné, par exemple, un cas d'utilisation courant consistant à faire glisser la position du calque à 60 ips.

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

Consultez la documentation d'Apple pour savoir comment les actions de calque sont résolues . La mise en œuvre du délégué sauterait un niveau de plus dans la cascade, mais dans mon cas, c'était trop compliqué en raison de la mise en garde concernant le délégué devant être défini sur l'UIView associé .

Edit: mis à jour grâce au commentateur soulignant que se NSNullconforme à CAAction.

Sur la base de la réponse de Sam et des difficultés de Simon ... ajoutez la référence du délégué après avoir créé le CSShapeLayer:

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

... ailleurs dans le fichier "m" ...

Essentiellement le même que celui de Sam sans la possibilité de basculer via l'arrangement de variable personnalisé "disableImplicitAnimations". Plus d'une approche "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];

}

En fait, je n'ai trouvé aucune des réponses comme étant la bonne. La méthode qui résout le problème pour moi était la suivante:

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

Ensuite, vous pouvez quelle que soit la logique qui s'y trouve, pour désactiver une animation spécifique, mais comme je voulais les supprimer toutes, j'ai renvoyé zéro.

Pour désactiver les animations de calques implicites dans Swift

CATransaction.setDisableActions(true)

Découvrez une méthode plus simple pour désactiver l'action à l'intérieur d'un CATransactionqui appelle en interne setValue:forKey:la kCATransactionDisableActionsclé:

[CATransaction setDisableActions:YES];

Rapide:

CATransaction.setDisableActions(true)

Ajoutez ceci à votre classe personnalisée où vous implémentez la méthode -drawRect (). Apportez des modifications au code pour répondre à vos besoins, pour moi, l'opacité a fait l'affaire pour arrêter l'animation en fondu enchaîné.

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

Si jamais vous avez besoin d'une solution très rapide (mais certes piratée), cela vaut peut-être la peine de le faire (Swift):

let layer = CALayer()

// set other properties
// ...

layer.speed = 999

Mise à jour pour accélérer et désactiver une seule animation de propriété implicite sous iOS et non sous 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)
}

Autre exemple, dans ce cas, l'élimination de deux animations implicites.

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

À partir d' iOS 7, il existe une méthode pratique qui fait exactement cela:

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

Pour désactiver l'animation ennuyeuse (floue) lors de la modification de la propriété de chaîne d'un CATextLayer, vous pouvez le faire:

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

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

puis utilisez-le comme tel (n'oubliez pas de configurer correctement votre CATextLayer, par exemple la police correcte, etc.):

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

Vous pouvez voir ma configuration complète de CATextLayer ici:

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"

Vous pouvez maintenant mettre à jour caTextLayer.string autant que vous le souhaitez =)

Inspiré par ceci et par cette réponse.

Essaye ça.

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

avertissement

Si vous définissez le délégué de l'instance UITableView, il se produit parfois un crash (probablement le plus fort de scrollview appelé récursivement).