Disabilitazione delle animazioni implicite in - [CALayer setNeedsDisplayInRect:]

Ho un livello con qualche codice di disegno complesso nel suo metodo -drawInContext: Sto cercando di ridurre al minimo la quantità di disegno che devo fare, quindi sto usando -setNeedsDisplayInRect: per aggiornare solo le parti modificate. Funziona magnificamente. Tuttavia, quando il sistema grafico aggiorna il mio livello, sta passando dalla vecchia alla nuova immagine usando una dissolvenza incrociata. Vorrei che passasse all'istante.

Ho provato a utilizzare CATransaction per disattivare le azioni e impostare la durata su zero, e nessuno dei due funziona. Ecco il codice che sto usando:

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

Esiste invece un metodo diverso su CATransaction che dovrei usare (ho anche provato -setValue: forKey: con kCATransactionDisableActions, stesso risultato).

Puoi farlo impostando il dizionario delle azioni sul layer per restituirlo [NSNull null]come animazione per la chiave appropriata. Ad esempio, io uso

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

layer.actions = newActions;

per disabilitare le animazioni di dissolvenza in apertura / chiusura durante l'inserimento o la modifica dei sublayer all'interno di uno dei miei livelli, nonché le modifiche nelle dimensioni e nei contenuti del livello. Credo che la contentschiave sia quella che stai cercando per evitare la dissolvenza incrociata sul disegno aggiornato.

Versione rapida:

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

Anche:

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

//foo

[CATransaction commit];

Quando si modifica la proprietà di un livello, CA solitamente crea un oggetto di transazione implicito per animare la modifica. Se non si desidera animare la modifica, è possibile disabilitare le animazioni implicite creando una transazione esplicita e impostando la proprietà kCATransactionDisableActions su true .

Objective-C

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

veloce

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

Oltre alla risposta di Brad Larson : per i livelli personalizzati (creati da te) puoi usare la delega invece di modificare il actionsdizionario dei livelli . Questo approccio è più dinamico e può essere più performante. E consente di disabilitare tutte le animazioni implicite senza dover elencare tutte le chiavi animabili.

Sfortunatamente, è impossibile usare UIViews come delegati di layer personalizzati, perché ognuno UIViewè già un delegato del proprio layer. Ma puoi usare una semplice classe di supporto come questa:

@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

Utilizzo (all'interno della 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

A volte è conveniente avere il controller di view come delegato per i sublayer personalizzati di view; in questo caso non è necessaria una classe helper, è possibile implementare il actionForLayer:forKey:metodo direttamente all'interno del controller.

Nota importante: non tentare di modificare il delegato del UIViewlivello sottostante (ad esempio per abilitare animazioni implicite) - accadranno cose brutte :)

Nota: se si desidera animare (non disabilitare l'animazione per) i ridisegni dei layer, è inutile inserire la [CALayer setNeedsDisplayInRect:]chiamata all'interno di un CATransaction, poiché il ridisegno effettivo può (e probabilmente accadrà) a volte più tardi. Il buon approccio è utilizzare proprietà personalizzate, come descritto in questa risposta .

Ecco una soluzione più efficiente, simile alla risposta accettata ma per Swift . In alcuni casi sarà meglio che creare una transazione ogni volta che si modifica il valore che è un problema di prestazioni come altri hanno menzionato, ad esempio un caso d'uso comune di trascinare la posizione del livello a 60fps.

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

Consulta i documenti di Apple per come vengono risolte le azioni di livello . L'implementazione del delegato salterebbe un altro livello nella cascata, ma nel mio caso era troppo disordinato a causa delle avvertenze sul delegato che doveva essere impostato sull'UIView associato .

Modifica: aggiornato grazie al commentatore sottolineando che è NSNullconforme CAAction.

Sulla base della risposta di Sam e delle difficoltà di Simon ... aggiungi il riferimento delegato dopo aver creato CSShapeLayer:

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

... altrove nel file "m" ...

Essenzialmente uguale a quello di Sam senza la possibilità di alternare tramite la disposizione variabile personalizzata "disableImplicitAnimations". Più di un approccio "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];

}

In realtà, non ho trovato nessuna delle risposte come quella giusta. Il metodo che risolve il problema per me è stato questo:

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

Quindi è possibile qualsiasi logica in esso, per disabilitare un'animazione specifica, ma poiché volevo rimuoverli tutti, sono tornato a zero.

Per disabilitare animazioni di livello implicite in Swift

CATransaction.setDisableActions(true)

Ho scoperto un metodo più semplice per disabilitare l'azione all'interno di una CATransactionche richiede internamente setValue:forKey:la kCATransactionDisableActionschiave:

[CATransaction setDisableActions:YES];

Swift:

CATransaction.setDisableActions(true)

Aggiungi questo alla tua classe personalizzata in cui stai implementando il metodo -drawRect (). Apporta modifiche al codice per soddisfare le tue esigenze, per me 'l'opacità' ha fatto il trucco per fermare l'animazione a dissolvenza incrociata.

-(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 hai mai bisogno di una soluzione molto rapida (ma per lo meno confusa) potrebbe valere la pena di fare solo (Swift):

let layer = CALayer()

// set other properties
// ...

layer.speed = 999

Aggiornato per velocizzare e disabilitare solo una animazione di proprietà implicita in iOS non 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)
}

Un altro esempio, in questo caso eliminando due animazioni implicite.

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

A partire da iOS 7 c'è un metodo pratico che fa proprio questo:

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

Per disabilitare la fastidiosa animazione (sfocata) quando si modifica la proprietà della stringa di un CATextLayer, è possibile effettuare questa operazione:

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 quindi usalo in questo modo (non dimenticare di impostare correttamente CATextLayer, ad esempio il carattere corretto, ecc.):

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

Puoi vedere la mia configurazione completa di CATextLayer qui:

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"

Ora puoi aggiornare caTextLayer.string quanto vuoi =)

Ispirato da questo e da questa risposta.

Prova questo.

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

avvertimento

Se imposti il ​​delegato dell'istanza UITableView, a volte si verifica un arresto anomalo (probabilmente il più basso di scrollview chiamato ricorsivamente).