Deaktivieren impliziter Animationen in - [CALayer setNeedsDisplayInRect:]

Ich habe eine Ebene mit komplexem Zeichnungscode in der Methode -drawInContext :. Ich versuche, den Zeichnungsaufwand zu minimieren, daher verwende ich -setNeedsDisplayInRect:, um nur die geänderten Teile zu aktualisieren. Das funktioniert hervorragend. Wenn das Grafiksystem jedoch meine Ebene aktualisiert, wechselt es mithilfe einer Überblendung vom alten zum neuen Bild. Ich möchte, dass es sofort umschaltet.

Ich habe versucht, mit CATransaction Aktionen auszuschalten und die Dauer auf Null zu setzen, und beides funktioniert nicht. Hier ist der Code, den ich verwende:

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

Gibt es eine andere Methode für CATransaction, die ich stattdessen verwenden sollte (ich habe auch versucht -setValue: forKey: mit kCATransactionDisableActions das gleiche Ergebnis).

Sie können dies tun, indem Sie das Aktionswörterbuch auf der zurückzugebenden Ebene festlegen [NSNull null] als Animation für die entsprechende Taste zurückgegeben wird. Zum Beispiel benutze ich

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

layer.actions = newActions;

Deaktivieren von Ein- / Ausblendanimationen beim Einfügen oder Ändern von Unterebenen in einer meiner Ebenen sowie von Änderungen der Größe und des Inhalts der Ebene. Ich glaube, der contentsSchlüssel ist der, nach dem Sie suchen, um das Überblenden bei aktualisierten Zeichnungen zu verhindern.

Schnelle Version:

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

Ebenfalls:

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

//foo

[CATransaction commit];

Wenn Sie die Eigenschaft eines Layers ändern, erstellt CA normalerweise ein implizites Transaktionsobjekt, um die Änderung zu animieren. Wenn Sie die Änderung nicht animieren möchten, können Sie implizite Animationen deaktivieren, indem Sie eine explizite Transaktion erstellen und die Eigenschaft kCATransactionDisableActions auf true setzen .

Ziel c

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

Schnell

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

Zusätzlich zu Brad Larsons Antwort : Für benutzerdefinierte Ebenen (die von Ihnen erstellt wurden) können Sie die Delegierung verwenden, anstatt die Ebenen zu ändernactions Wörterbuch ändern. Dieser Ansatz ist dynamischer und kann performanter sein. Außerdem können alle impliziten Animationen deaktiviert werden, ohne dass alle animierbaren Schlüssel aufgelistet werden müssen.

Leider ist es nicht möglich, UIViews als benutzerdefinierte Layer-Delegaten zu verwenden, da jeder UIViewbereits ein Delegat seiner eigenen Ebene ist. Sie können jedoch eine einfache Hilfsklasse wie diese verwenden:

@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

Verwendung (innerhalb der Ansicht):

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

Manchmal ist es praktisch, den Controller von view als Delegaten für die benutzerdefinierten Unterschichten von view zu haben. In diesem Fall ist keine Hilfsklasse erforderlich. Sie können die actionForLayer:forKey:Methode direkt im Controller implementieren .

Wichtiger Hinweis: Versuchen Sie nicht, den Delegaten der UIViewzugrunde liegenden Ebene zu ändern (z. B. um implizite Animationen zu aktivieren) - es werden schlimme Dinge passieren :)

Hinweis: Wenn Sie Ebenen- Neuzeichnungen animieren (nicht deaktivieren) möchten, ist es sinnlos, einen [CALayer setNeedsDisplayInRect:]Aufruf in eine zu setzen CATransaction, da das tatsächliche Neuzeichnen manchmal (und wahrscheinlich auch später) erfolgen kann. Der gute Ansatz besteht darin, benutzerdefinierte Eigenschaften zu verwenden, wie in dieser Antwort beschrieben .

Hier ist eine effizientere Lösung, ähnlich der akzeptierten Antwort, jedoch für Swift . In einigen Fällen ist es besser, als jedes Mal eine Transaktion zu erstellen, wenn Sie den Wert ändern, was ein Leistungsproblem darstellt, wie andere bereits erwähnt haben, z. B. den allgemeinen Anwendungsfall, die Ebenenposition mit 60 fps zu verschieben.

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

Siehe Apple - Dokumentation für wie Schicht Maßnahmen gelöst werden . Das Implementieren des Delegaten würde eine weitere Ebene in der Kaskade überspringen, aber in meinem Fall war dies zu chaotisch, da der Delegat auf die zugehörige UIView eingestellt werden musste .

Bearbeiten: Aktualisiert dank des Kommentators, der darauf hinweist, dass dies NSNullkonform ist CAAction.

Basierend auf Sams Antwort und Simons Schwierigkeiten ... fügen Sie die Delegatenreferenz nach dem Erstellen des CSShapeLayer hinzu:

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

... an anderer Stelle in der "m" -Datei ...

Im Wesentlichen dasselbe wie bei Sam ohne die Möglichkeit, über die benutzerdefinierte Variablenanordnung "disableImplicitAnimations" umzuschalten. Eher ein "Hard-Wire" -Ansatz.

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

}

Eigentlich fand ich keine der Antworten richtig. Die Methode, die das Problem für mich löst, war folgende:

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

Dann können Sie jede Logik darin verwenden, um eine bestimmte Animation zu deaktivieren, aber da ich sie alle entfernen wollte, gab ich null zurück.

So deaktivieren Sie implizite Ebenenanimationen in Swift

CATransaction.setDisableActions(true)

Es wurde eine einfachere Methode zum Deaktivieren der Aktion in einem System gefunden CATransaction, die intern setValue:forKey:den kCATransactionDisableActionsSchlüssel anfordert:

[CATransaction setDisableActions:YES];

Schnell:

CATransaction.setDisableActions(true)

Fügen Sie dies Ihrer benutzerdefinierten Klasse hinzu, in der Sie die Methode -drawRect () implementieren. Nehmen Sie Änderungen am Code vor, um Ihren Anforderungen zu entsprechen. Für mich hat 'Opazität' den Trick getan, um Cross-Fade-Animationen zu stoppen.

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

Wenn Sie jemals eine sehr schnelle (aber zugegebenermaßen hackige) Lösung benötigen, lohnt es sich möglicherweise, nur (Swift) zu tun:

let layer = CALayer()

// set other properties
// ...

layer.speed = 999

Aktualisiert für schnelles und Deaktivieren nur einer impliziten Eigenschaftsanimation unter iOS und nicht unter 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)
}

Ein weiteres Beispiel: In diesem Fall werden zwei implizite Animationen entfernt.

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

Ab iOS 7 gibt es eine praktische Methode, die genau dies tut:

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

So deaktivieren Sie die nervige (verschwommene) Animation beim Ändern der Zeichenfolgeeigenschaft eines CATextLayer:

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

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

und verwenden Sie es dann wie folgt (vergessen Sie nicht, Ihren CATextLayer ordnungsgemäß einzurichten, z. B. die richtige Schriftart usw.):

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

Sie können mein komplettes Setup von CATextLayer hier sehen:

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"

Jetzt können Sie caTextLayer.string so oft aktualisieren, wie Sie möchten =)

Inspiriert von dieser und dieser Antwort.

Versuche dies.

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

Warnung

Wenn Sie den Delegaten der UITableView-Instanz festlegen, kommt es manchmal zu einem Absturz.