Wiederherstellen der Animation an der Stelle, an der sie abgebrochen wurde, wenn die App vom Hintergrund aus fortgesetzt wird

Hey, ich hatte stolperte über die gleiche Sache in meinem Spiel, und schließlich finden eine etwas andere Lösung, als Sie, die Sie möglicherweise mögen 🙂 ich dachte, ich würde teilen die Abhilfe, die ich gefunden...

Meinem Fall ist mit UIView/UIImageView Animationen, aber es ist im Grunde immer noch CAAnimations im Kern... Der Kern meiner Methode ist, dass ich kopieren/speichern der aktuellen animation auf einen Blick, und lassen Sie dann Apple pausieren/fortsetzen der Arbeit noch, aber vor der Wiederaufnahme füge ich meiner animation wieder auf. So lassen Sie mich ein ganz einfaches Beispiel:

Sagen wir, ich habe eine UIView genannt movingView. Die UIView - center animiert über den standard [UIView animateWithDuration...] nennen. Mit den genannten QA1673 code, es funktioniert großartig, anhalten/fortsetzen (bei verlassen der app)... aber egal, ich merkte bald, dass beim beenden, ob ich anhalten oder nicht, die animation wurde komplett entfernt... und hier war ich in Ihrer position.

Also mit diesem Beispiel, hier ist, was ich getan habe:

• Habe eine variable in der header-Datei heißt so etwas wie animationViewPositionder Typ *CAAnimation**.

• Wenn die app beendet, um hintergrund, dass ich dies tun:

  animationViewPosition = [[movingView.layer animationForKey:@"position"] copy]; //I know position is the key in this case...
  [self pauseLayer:movingView.layer]; //this is the Apple method from QA1673

  • Hinweis: die 2 ^ - Aufrufe werden in ein Verfahren, das die Prozedur für die UIApplicationDidEnterBackgroundNotification (ähnlich wie du)
  • Hinweis 2: Wenn Sie nicht wissen, was der Schlüssel ist (von der animation), können Sie eine Schleife durch die view-Schicht " animationKeys' - Eigenschaft, und melden Sie diese heraus (Mitte der animation vermutlich).

• Nun in meinem UIApplicationWillEnterForegroundnotification handler:

  if (animationViewPosition != nil)
  {
      [movingView.layer addAnimation:animationViewPosition forKey:@"position"]; //re-add the core animation to the view
      [animationViewPosition release]; //since we 'copied' earlier
      animationViewPosition = nil;
  }
  [self resumeLayer:movingView.layer]; //Apple's method, which will resume the animation at the position it was at when the app exited

Und das ist ziemlich viel! Es hat bei mir geklappt so weit 🙂

Können Sie ganz einfach verlängern es mehr Animationen oder Ansichten nur wiederholen diese Schritte für jede animation. Es funktioniert sogar für das unterbrechen/wiederaufnehmen der UIImageView-Animationen, also die standard - [Bildansicht startAnimating]. Die Ebene animation-Schlüssel für die (übrigens) ist "Inhalt".

Liste 1) Anhalten und Fortsetzen von Animationen.

-(void)pauseLayer:(CALayer*)layer
{
    CFTimeInterval pausedTime = [layer convertTime:CACurrentMediaTime() fromLayer:nil];
    layer.speed = 0.0;
    layer.timeOffset = pausedTime;
}

-(void)resumeLayer:(CALayer*)layer
{
    CFTimeInterval pausedTime = [layer timeOffset];
    layer.speed = 1.0;
    layer.timeOffset = 0.0;
    layer.beginTime = 0.0;
    CFTimeInterval timeSincePause = [layer convertTime:CACurrentMediaTime() fromLayer:nil] - pausedTime;
    layer.beginTime = timeSincePause;
}

InformationsquelleAutor der Antwort cclogg

Kann ich nicht kommentieren, so will ich hinzufügen, es als Antwort.

Ich verwendet cclogg die Lösung, aber meine app stürzt ab, wenn die animation die Sicht war entfernt von seinem superview, wieder Hinzugefügt, und werde dann in den hintergrund.

Die animation wurde unendlich durch Einstellung animation.repeatCount zu Float.infinity.

Die Lösung, die ich hatte, war zu setzen animation.removedOnCompletion zu false.

Es ist sehr komisch, dass es funktioniert, weil die animation ist nie abgeschlossen. Hat jemand eine Erklärung, ich mag es zu hören.

Noch ein Tipp: Wenn Sie entfernen die Aussicht von seinem superview. Vergessen Sie nicht, entfernen Sie die Beobachter durch den Aufruf NSNotificationCenter.defaultCenter().removeObserver(...).

InformationsquelleAutor der Antwort Pepijn

War ich in der Lage, zur Wiederherstellung der animation (aber nicht die animation-position) speichern Sie eine Kopie der aktuellen animation und das hinzufügen es wieder auf fortsetzen. Ich rief startAnimation beim laden und beim betreten der Vorder-und pause bei der Eingabe der hintergrund.

- (void) startAnimation {
    //On first call, setup our ivar
    if (!self.myAnimation) {
        self.myAnimation = [CABasicAnimation animationWithKeyPath:@"transform"];
        /*
         Finish setting up myAnimation
         */
    }

    //Add the animation to the layer if it hasn't been or got removed
    if (![self.layer animationForKey:@"myAnimation"]) {
        [self.layer addAnimation:self.spinAnimation forKey:@"myAnimation"];
    }
}

- (void) pauseAnimation {
    //Save the current state of the animation
    //when we call startAnimation again, this saved animation will be added/restored
    self.myAnimation = [[self.layer animationForKey:@"myAnimation"] copy];
}

InformationsquelleAutor der Antwort Warpling

Schreibe ich eine Swift 4 version-Erweiterung basierend auf dem @cclogg und @Matej Bukovinski Antworten. Alles, was Sie brauchen, ist zu nennen layer.makeAnimationsPersistent()

Voll Kernaussage hier: CALayer+AnimationPlayback.swift, CALayer+PersistentAnimations.swift

Core-Teil:

public extension CALayer {
    static private var persistentHelperKey = "CALayer.LayerPersistentHelper"

    public func makeAnimationsPersistent() {
        var object = objc_getAssociatedObject(self, &CALayer.persistentHelperKey)
        if object == nil {
            object = LayerPersistentHelper(with: self)
            let nonatomic = objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC
            objc_setAssociatedObject(self, &CALayer.persistentHelperKey, object, nonatomic)
        }
    }
}

public class LayerPersistentHelper {
    private var persistentAnimations: [String: CAAnimation] = [:]
    private var persistentSpeed: Float = 0.0
    private weak var layer: CALayer?

    public init(with layer: CALayer) {
        self.layer = layer
        addNotificationObservers()
    }

    deinit {
        removeNotificationObservers()
    }
}

private extension LayerPersistentHelper {
    func addNotificationObservers() {
        let center = NotificationCenter.default
        let enterForeground = NSNotification.Name.UIApplicationWillEnterForeground
        let enterBackground = NSNotification.Name.UIApplicationDidEnterBackground
        center.addObserver(self, selector: #selector(didBecomeActive), name: enterForeground, object: nil)
        center.addObserver(self, selector: #selector(willResignActive), name: enterBackground, object: nil)
    }

    func removeNotificationObservers() {
        NotificationCenter.default.removeObserver(self)
    }

    func persistAnimations(with keys: [String]?) {
        guard let layer = self.layer else { return }
        keys?.forEach { (key) in
            if let animation = layer.animation(forKey: key) {
                persistentAnimations[key] = animation
            }
        }
    }

    func restoreAnimations(with keys: [String]?) {
        guard let layer = self.layer else { return }
        keys?.forEach { (key) in
            if let animation = persistentAnimations[key] {
                layer.add(animation, forKey: key)
            }
        }
    }
}

@objc extension LayerPersistentHelper {
    func didBecomeActive() {
        guard let layer = self.layer else { return }
        restoreAnimations(with: Array(persistentAnimations.keys))
        persistentAnimations.removeAll()
        if persistentSpeed == 1.0 { //if layer was playing before background, resume it
            layer.resumeAnimations()
        }
    }

    func willResignActive() {
        guard let layer = self.layer else { return }
        persistentSpeed = layer.speed
        layer.speed = 1.0 //in case layer was paused from outside, set speed to 1.0 to get all animations
        persistAnimations(with: layer.animationKeys())
        layer.speed = persistentSpeed //restore original speed
        layer.pauseAnimations()
    }
}

InformationsquelleAutor der Antwort ArtFeel