material-motion / motion-animator-objc

A Motion Animator creates performant, interruptible iOS animations from motion specs.

layout	permalink
default	/

Material Motion

Welcome to the Material Motion documentation site. Please check out the Starmap for our engineering specification and our Team documentation to learn more about our culture.

Current status: early development.

Chat with us on Discord.

Android platform support

Library	Build status	Coverage	Version	Docs	Issues
conventions-android
gestures-android
indefinite-observable-android
material-motion-android
material-motion-rebound-android
physics-android

Apple platform support

Library	Build status	Coverage	Version	Platforms	Docs	Issues
conventions-objc
indefinite-observable-swift
material-motion-pop-swift
material-motion-swift

Web platform support

Library	Build status	Coverage	Version	Issues
indefinite-observable-js
material-motion-js

Misc libraries

Library	Build status	Coverage	Version	Issues
apidiff
loopy
material-motion
milemarker
starmap
sublime
tools
tsc-reduction

motion-animator-objc's Issues

Add support for a static animator animate API

This would be similar to UIView's animate APIs:

MotionAnimator.animate(withTiming: timing) {

}

The implementation would simply create a throw-away motion animator instance and call through to the instance APIs.

Add a CATransaction API for adding a core animation tracer

It's often desirable to trace animations for a specific animation scope.

timeScaleFactor should likely be mapped to the animation's speed property

We currently augment the duration/delay of the animation, but setting the timeScaleFactor to the animation's speed should give us better control over the speed of spring animations as well.

Explore support for keyframe timing

How might we represent timing for multiple keyframes?

Add didComplete parameter to the completion blocks

Adding support for explicit animations is trivial because we can do a one-to-one mapping of animations to completion handlers.

Adding support for implicit animations, however, is non-trivial because multiple animations map to the same completion handler. We'll have to implement the animation delegate on each added animation and coalesce the overall completion state into a single invocation of the completion handler.

This would bring our API closer in alignment to UIView's animation APIs.

Add behavioral tests validating that the animator's implicit and additive animation behavior is consistent across all key paths

We want to show that the MotionAnimator can be used to animate both UIView-associated layers and headless layers in the same manner.

MDMConfigureAnimation should not be making animations additive if wantsAdditive if false

Size and point animations are always being made additive, regardless of the value of wantsAdditive.

Bazel improvements

• WORKSPACE should use http_archive instead of git_repository
• Bump build_bazel_rules_apple to 0.1.0.

Explore routing implicit animations through CAAction rather than our own internal record keeping

We may find it beneficial to to implement CAAction so that our animations get routed through the expected action architecture. The challenge is that we need to be able to provide the timing struct to the action implementation and that action implementation needs to be able to create an animation object using the animator's configurations. This may require splitting the animator's animation creation logic out to some standalone method.

Some references:

• https://stackoverflow.com/questions/10298905/custom-property-animation-with-actionforkey-how-do-i-get-the-new-value-for-the

Add support for relative timing

Consider the following spec:

struct MotionSpec spec = {
  .expand = {
    .verticalMovement = {
      .delay = 0.000, .duration = 0.350, .curve = EaseInEaseOut,
    },
    .scaling = {
      .delay = 0.000, .duration = 0.350, .curve = EaseInEaseOut,
    },
  },
  .collapse = {
    .verticalMovement = {
      .delay = 0.000, .duration = 0.350, .curve = EaseInEaseOut,
    },
    .scaling = {
      .delay = 0.000, .duration = 0.350, .curve = EaseInEaseOut,
    },
  },
};

All of the animations are described in relation to a relative timeline. If the timing could correspondingly be described in a relative fashion, our struct might look like this:

struct MotionSpec spec = {
  .expand = {
    .verticalMovement = {
      .delay = 0.0, .duration = 1.0, .curve = EaseInEaseOut,
    },
    .scaling = {
      .delay = 0.0, .duration = 1.0, .curve = EaseInEaseOut,
    },
  },
  .collapse = {
    .verticalMovement = {
      .delay = 0.0, .duration = 1.0, .curve = EaseInEaseOut,
    },
    .scaling = {
      .delay = 0.0, .duration = 1.0, .curve = EaseInEaseOut,
    },
  },
};

animator.relativeTimingDuration = 0.350;

All animation timing would correspondingly be multiplied by the relativeTimingDuration.

Add parameter names to MDMCoreAnimationTraceable's block

This will improve auto completion when calling the API.

Implement additive support for CGRect types

Returning `NSNull` for swapped animation implementations causes crash

In the method, ActionForKey(CALayer *layer, SEL _cmd, NSString *event), the returned NSNull value was causing crashes because it does not respond to selectors (like runAction:forKey:). This is easily reproduced when running the unit test suite on iOS 8.2 or lower simulators. The contract for actionForKey: should return nil if no action was found, which is what we want in this case.

Add a unit test verifying that a timeScaleFactor of 0 results in the same result as a duration of 0

Opacity should not implicitly animate by default

As confirmed by #60.

Add a unit test validating that every animatable CALayer property can be animated additively

If duration is negative treat it as 0 rather than Core Animation's default of 0.25

Make MDMMakeAnimationAdditive return a BOOL

MDMAnimatableKeyPaths.h fails to build on Xcode 7

I don't think swift_wrapper is supported in Xcode 7.

Add guide on how to animate headless CALayer instances

Add support for relative values

Values passed to the animator are currently absolute. It would be nice to also be able to provide relative values.

// Move a view 50 points down.
    [animator animateWithTiming:timing
                        toLayer:view.layer
             withRelativeValues:@[ @0, @50 ]
                        keyPath:MDMKeyPathY];

This feature should take care when implementing support for shouldReverseValues.

testCommitAndRemoveAllAnimationsCommitsThePresentationValue needs to be renamed to testStopAllAnimationsCommitsThePresentationValue

Add support for animating with a CABasicAnimation as a template

The need for this comes from wanting to be able to inherit UIView animations in headless sublayers.

Provide a way to pass velocity to spring animations

v1.3.0 of the interchange introduced a new API for capturing velocity in a motion spec: https://github.com/material-motion/motion-interchange-objc/releases/tag/v1.3.0

We should support this property and implement it in the motion animator.

• There is also an open question of how to allow clients to provide velocity to the animator.

Crash when completion blocks are `nil` for "legacy" API

Calling either of these two methods with a nil completion block will crash.

 [animator animateWithTiming:timing
                   animations:animations
                   completion:nil];

[animator animateWithTiming:timing
                       toLayer:aLayer
                    withValues:values
                      keyPath:keyPath
                   completion:nil];

Add a unit test verifying that CATransaction completion blocks are invoked when animator animation durations are 0

[CATransaction begin];
[CATransaction setCompletionBlock:^{
  NSLog(@"Did complete");
}];
[_animator animateWithTiming:timing ...];
[CATransaction commit];

If timing.duration == 0 then the transaction's completion block should still be invoked.

If beginFromCurrentState and the animator is additive, don't read from presentation layer

When making additive animations we always want to be animating from the latest model value, not the latest presentation layer value.

When we're not making additive animations, we do want to go from the current presentation layer value.