Wyłączanie niejawnych animacji w - [CALayer setNeedsDisplayInRect:]

Mam warstwę ze złożonym kodem rysunkowym w metodzie -drawInContext:. Próbuję zminimalizować ilość rysowania, które muszę zrobić, więc używam -setNeedsDisplayInRect: do aktualizacji tylko zmienionych części. To działa świetnie. Jednak gdy system graficzny aktualizuje moją warstwę, przechodzi ze starego do nowego obrazu przy użyciu efektu przenikania. Chciałbym, żeby przełączało się natychmiast.

Próbowałem użyć CATransaction, aby wyłączyć akcje i ustawić czas trwania na zero, ale żadna z nich nie działa. Oto kod, którego używam:

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

Czy istnieje inna metoda na CATransaction, której powinienem użyć zamiast tego (próbowałem również -setValue: forKey: z kCATransactionDisableActions, ten sam wynik).

Możesz to zrobić, ustawiając słownik akcji na warstwie, aby powracał [NSNull null]jako animacja dla odpowiedniego klucza. Na przykład używam

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

layer.actions = newActions;

aby wyłączyć animacje pojawiania się / zanikania podczas wstawiania lub zmiany podwarstw w jednej z moich warstw, a także zmiany rozmiaru i zawartości warstwy. Uważam, że contentskluczem jest ten, którego szukasz, aby zapobiec przenikaniu na zaktualizowanym rysunku.

Wersja Swift:

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

Również:

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

//foo

[CATransaction commit];

Po zmianie właściwości warstwy ośrodek CA zwykle tworzy niejawny obiekt transakcji, aby ożywić zmianę. Jeśli nie chcesz animować zmiany, możesz wyłączyć niejawne animacje, tworząc jawną transakcję i ustawiając jej właściwość kCATransactionDisableActions na wartość true .

Cel C

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

Szybki

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

Oprócz odpowiedzi Brada Larsona : dla warstw niestandardowych (które są tworzone przez Ciebie) możesz użyć delegowania zamiast modyfikowania actionssłownika warstwy . To podejście jest bardziej dynamiczne i może być bardziej wydajne. I umożliwia wyłączenie wszystkich niejawnych animacji bez konieczności wyszczególniania wszystkich animowanych klawiszy.

Niestety, nie można używać UIViews jako delegatów warstwy niestandardowej, ponieważ każda z nich UIViewjest już delegatem swojej własnej warstwy. Ale możesz użyć prostej klasy pomocniczej, takiej jak ta:

@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

Zastosowanie (wewnątrz widoku):

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

Czasami wygodnie jest mieć kontroler widoku jako delegata dla niestandardowych podwarstw widoku; w tym przypadku nie ma potrzeby stosowania klasy pomocniczej, można zaimplementować actionForLayer:forKey:metodę bezpośrednio w kontrolerze.

Ważna uwaga: nie próbuj modyfikować delegata UIViewwarstwy bazowej (np. Aby włączyć niejawne animacje) - zdarzają się złe rzeczy :)

Uwaga: jeśli chcesz animować (nie wyłączać animacji) przerysowania warstw, nie ma sensu umieszczać [CALayer setNeedsDisplayInRect:]wywołania wewnątrz a CATransaction, ponieważ faktyczne przerysowanie może (i prawdopodobnie nastąpi) później. Dobrym podejściem jest użycie właściwości niestandardowych, jak opisano w tej odpowiedzi .

Oto bardziej wydajne rozwiązanie, podobne do akceptowanej odpowiedzi, ale dla Swift . W niektórych przypadkach będzie to lepsze niż tworzenie transakcji za każdym razem, gdy modyfikujesz wartość, która ma wpływ na wydajność, jak wspominali inni, np. Częsty przypadek użycia przeciągania pozycji warstwy przy 60 klatkach na sekundę.

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

Zobacz dokumentację Apple, aby dowiedzieć się, jak rozwiązuje się działania warstw . Zaimplementowanie delegata spowodowałoby pominięcie jeszcze jednego poziomu w kaskadzie, ale w moim przypadku było to zbyt bałagan z powodu zastrzeżenia dotyczącego delegata, który musi być ustawiony na skojarzony UIView .

Edycja: Zaktualizowano dzięki komentatorowi wskazującemu, że NSNulljest zgodny z CAAction.

W oparciu o odpowiedź Sama i trudności Simona ... dodaj odwołanie delegata po utworzeniu CSShapeLayer:

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

... w innym miejscu w pliku „m” ...

Zasadniczo to samo, co u Sama, bez możliwości przełączania się za pomocą niestandardowego układu zmiennych „disableImplicitAnimations”. Bardziej podejście „sztywnego drutu”.

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

}

Właściwie nie znalazłem żadnej odpowiedzi jako właściwej. Metoda, która rozwiązuje ten problem była dla mnie następująca:

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

Wtedy możesz dowolną logikę, aby wyłączyć określoną animację, ale ponieważ chciałem je wszystkie usunąć, zwróciłem zero.

Aby wyłączyć niejawne animacje warstw w Swift

CATransaction.setDisableActions(true)

Dowiedział się prostszą metodę do działania wyłączyć Wewnątrz CATransactionże wewnętrznie wzywa setValue:forKey:do kCATransactionDisableActionsklucza:

[CATransaction setDisableActions:YES];

Szybki:

CATransaction.setDisableActions(true)

Dodaj to do swojej klasy niestandardowej, w której implementujesz metodę -drawRect (). Wprowadź zmiany w kodzie, aby dostosować go do swoich potrzeb, dla mnie „krycie” wystarczyło, aby zatrzymać animację przechodzenia.

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

Jeśli kiedykolwiek będziesz potrzebować bardzo szybkiej (ale wprawdzie hakerskiej) poprawki, warto po prostu zrobić (Swift):

let layer = CALayer()

// set other properties
// ...

layer.speed = 999

Zaktualizowano w celu szybkiego i wyłączenia tylko jednej niejawnej animacji właściwości w systemie iOS, a nie w systemie 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)
}

Inny przykład, w tym przypadku eliminacja dwóch niejawnych animacji.

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

Od iOS 7 istnieje wygodna metoda, która robi to:

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

Aby wyłączyć irytującą (rozmytą) animację podczas zmiany właściwości ciągu CATextLayer, możesz to zrobić:

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

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

a następnie użyj go w ten sposób (nie zapomnij odpowiednio ustawić CATextLayer, np. poprawnej czcionki itp.):

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

Możesz zobaczyć moją pełną konfigurację CATextLayer tutaj:

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"

Teraz możesz aktualizować caTextLayer.string tyle, ile chcesz =)

Zainspirowany tym i tą odpowiedzią.

Spróbuj tego.

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

Ostrzeżenie

Jeśli ustawisz delegata instancji UITableView, czasami zdarzają się awarie (prawdopodobnie najczęstszy przewijany widok nazywa się rekurencyjnie).