This reverts commit 699e896, reversing

changes made to 85208cd.

Author: Jeff Verkoeyen

CHANGELOG.md

@@ -1,70 +1,3 @@
-# 4.0.0
-
-This major release adds support for composable transitions. See the catalog app for a variety of
-examples making use of this new functionality.
-
-## Fixed issues
-
-- [Transitions would not complete if the presentation controller didn't implement the startWithContext method](https://github.com/material-motion/transitioning-objc/pull/45)
-
-## Breaking changes
-
-- `MDMTransitionWithFallback`'s return value is now nonnull. If you depended on the nil behavior,
-you must now conform to the new protocol `MDMTransitionWithFeasibility` and return `NO` for
-`canPerformTransitionWithContext:`.
-- `MDMTransitionDirection` has been renamed to `TransitionDirection` in Swift.
-
-## New features
-
-`MDMTransitionWithFeasibility` allows a transition to indicate whether it is capable of performing
-the transition with a given context.
-
-The new `composeWithTransition:` API on `MDMTransitionContext` makes it possible to build modular
-transition objects that delegate responsibility out to other transition objects. View the
-`PhotoAlbumTransition` example transition to see the following code in action:
-
-```swift
-context.compose(with: FadeTransition(target: .foreView, style: .fadeIn))
-context.compose(with: SpringFrameTransition(target: .target(snapshotContextView),
-                                            size: fitSize))
-
-if let toolbar = foreDelegate.toolbar(for: self) {
-  context.compose(with: SlideUpTransition(target: .target(toolbar)))
-}
-```
-
-## Source changes
-
-* [Update Xcode build settings to Xcode 9 warnings and resolve build error.](https://github.com/material-motion/transitioning-objc/commit/5ed85cdc795ae6660901c5e2ae237732f04649e1) (Jeff Verkoeyen)
-* [Rework multi-transition support using composition. (#43)](https://github.com/material-motion/transitioning-objc/commit/0b57361557476c7d3ecb8f4c9878da21a2e735ab) (featherless)
-* [Fix the Swift symbol name for MDMTransitionDirection. (#44)](https://github.com/material-motion/transitioning-objc/commit/4cdcf4ca0324a1f83d572440887fe5a5d18ee00b) (featherless)
-* [Fix bug where transitions would not complete if the presentation controller didn't implement the startWithContext method. (#45)](https://github.com/material-motion/transitioning-objc/commit/784328dae8509df0a2beb3a5afa9701f1e275950) (featherless)
-* [Fix broken unit tests.](https://github.com/material-motion/transitioning-objc/commit/46c92ebcab642969ba70ea43aa512cac1cc3cad4) (Jeff Verkoeyen)
-* [Add multi-transition support. (#40)](https://github.com/material-motion/transitioning-objc/commit/8653958a5a9419891861fb6fd7648791ca3c744c) (featherless)
-* [Remove unused protocol forward declaration.](https://github.com/material-motion/transitioning-objc/commit/74c1655fc3614e5e9788db8b53e8bff83691137a) (Jeff Verkoeyen)
-
-## API changes
-
-### MDMTransitionWithCustomDuration
-
-*changed* protocol `MDMTransitionWithCustomDuration` now conforms to `MDMTransition`.
-
-### MDMTransitionWithFallback
-
-*changed* protocol `MDMTransitionWithFallback` now conforms to `MDMTransition`.
-
-### MDMTransitionWithFeasibility
-
-*new* protocol `MDMTransitionWithFeasibility`.
-
-### MDMTransitionContext
-
-*new* method `composeWithTransition:`
-
-## Non-source changes
-
-* [Add platform to the Podfile per pod install recommendation.](https://github.com/material-motion/transitioning-objc/commit/7384187b2ddd6a2760f5279cabb5032ea3b1e24e) (Jeff Verkoeyen)
-
 # 3.2.1
 
 This patch release resolves Xcode 9 compiler warnings.

MotionTransitioning.podspec

@@ -1,7 +1,7 @@
 Pod::Spec.new do |s|
   s.name         = "MotionTransitioning"
   s.summary      = "Light-weight API for building UIViewController transitions."
-  s.version      = "4.0.0"
+  s.version      = "3.2.1"
   s.authors      = "The Material Motion Authors"
   s.license      = "Apache 2.0"
   s.homepage     = "https://github.com/material-motion/transitioning-objc"

Podfile

@@ -1,6 +1,5 @@
 workspace 'MotionTransitioning.xcworkspace'
 use_frameworks!
-platform :ios, '8.0'
 
 target "TransitionsCatalog" do
   pod 'CatalogByConvention'

Podfile.lock

@@ -1,6 +1,6 @@
 PODS:
   - CatalogByConvention (2.1.1)
-  - MotionTransitioning (4.0.0)
+  - MotionTransitioning (3.2.1)
 
 DEPENDENCIES:
   - CatalogByConvention
@@ -12,8 +12,8 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   CatalogByConvention: c3a5319de04250a7cd4649127fcfca5fe3322a43
-  MotionTransitioning: be4161ebcbff7911a1d9c4549e396f486041ca6f
+  MotionTransitioning: 01e7fcd6e2974985057109e0a4c98ea546cd5947
 
-PODFILE CHECKSUM: 25d5942fb7698339a03667bb46c3fbb77529b92d
+PODFILE CHECKSUM: db2e7ac8d9d65704a2cbffa0b77e39a574cb7248
 
 COCOAPODS: 1.2.1

README.md

@@ -14,7 +14,7 @@ you can pick the custom transition you want to use:
 ```swift
 let viewController = MyViewController()
 viewController.transitionController.transition = CustomTransition()
-present(viewController, animated: true)
+present(modalViewController, animated: true)
 ```
 
 ```objc
@@ -102,7 +102,7 @@ commands:
 ## Guides
 
 1. [Architecture](#architecture)
-2. [How to create a fade transition](#how-to-create-a-fade-transition)
+2. [How to create a simple transition](#how-to-create-a-simple-transition)
 3. [How to customize presentation](#how-to-customize-presentation)
 4. [How to customize navigation controller transitions](#how-to-customize-navigation-controller-transitions)
 
@@ -118,27 +118,23 @@ MotionTransitioning provides a thin layer atop these protocols with the followin
 - Every view controller has its own **transition controller**. This encourages choosing the
   transition based on the context.
 - Transitions are represented in terms of **backward/forward** rather than from/to. When presenting,
-  we're moving forward. When dismissing, we're moving backward. This allows transition code to be
-  written with fewer conditional branches of logic.
-- Transition objects can customize their behavior by conforming to the family of `TransitionWith*` protocols.
+  we're moving forward. When dismissing, we're moving backward. This makes it easier to refer to
+  each "side" of a transition consistently.
+- Transition objects can customize their behavior by conforming to more `TransitionWith*` protocols.
+  This protocol-oriented design is more Swift-friendly than a variety of optional methods on a
+  protocol.
+- But most importantly: **this library handles the plumbing, allowing you to focus on the motion**.
 
-### How to create a fade transition
+### How to create a simple transition
 
-We'll create a new fade transition so that the following lines of code customizes the presentation
-and dismissal of our view controller:
-
-```swift
-let viewController = MyViewController()
-viewController.transitionController.transition = FadeTransition()
-present(viewController, animated: true)
-```
+In this guide we'll create scaffolding for a simple transition.
 
 #### Step 1: Define a new Transition type
 
-A transition is an `NSObject` subclass that conforms to the `Transition` protocol.
+Transitions must be `NSObject` types that conform to the `Transition` protocol.
 
-The only method you have to implement is `start(with context:)`. This method is invoked each time
-the associated view controller is presented or dismissed.
+The sole method we're expected to implement, `start`, is invoked each time the view controller is
+presented or dismissed.
 
 ```swift
 final class FadeTransition: NSObject, Transition {
@@ -150,11 +146,7 @@ final class FadeTransition: NSObject, Transition {
 
 #### Step 2: Invoke the completion handler once all animations are complete
 
-Every transition is provided with a transition context. The transition context must be told when the
-transition's motion has completed so that the context can then inform UIKit of the view controller
-transition's completion.
-
-If using explicit Core Animation animations:
+If using Core Animation explicitly:
 
 ```swift
 final class FadeTransition: NSObject, Transition {
@@ -172,7 +164,7 @@ final class FadeTransition: NSObject, Transition {
 }
 ```
 
-If using implicit UIView animations:
+If using UIView implicit animations:
 
 ```swift
 final class FadeTransition: NSObject, Transition {
@@ -189,57 +181,41 @@ final class FadeTransition: NSObject, Transition {
 
 #### Step 3: Implement the motion
 
-With the basic scaffolding in place, you can now implement your motion. For simplicity's sake we'll
-use implicit UIView animations in this example to build our motion, but you're free to use any
-animation system you prefer.
-
-```swift
-final class FadeTransition: NSObject, Transition {
-  func start(with context: TransitionContext) {
-    // This is a fairly rudimentary way to calculate the values on either side of the transition.
-    // You may want to try different patterns until you find one that you prefer.
-    // Also consider trying the MotionAnimator library provided by the Material Motion team:
-    // https://github.com/material-motion/motion-animator-objc
-    let backOpacity = 0
-    let foreOpacity = 1
-    let initialOpacity = context.direction == .forward ? backOpacity : foreOpacity
-    let finalOpacity = context.direction == .forward ? foreOpacity : backOpacity
-    context.foreViewController.view.alpha = initialOpacity
-    UIView.animate(withDuration: context.duration, animations: {
-      context.foreViewController.view.alpha = finalOpacity
-
-    }, completion: { didComplete in
-      context.transitionDidEnd()
-    })
-  }
-}
-```
+With the basic scaffolding in place, you can now implement your motion.
 
 ### How to customize presentation
 
-Customize the presentation of a transition when you need to do any of the following:
+You'll customize the presentation of a transition when you need to do any of the following:
 
 - Add views, such as dimming views, that live beyond the lifetime of the transition.
 - Change the destination frame of the presented view controller.
 
-You have two options for customizing presentation:
+#### Step 1: Subclass UIPresentationController
 
-1. Use the provided `TransitionPresentationController` API.
-2. Build your own UIPresentationController subclass.
+You must subclass UIPresentationController in order to implement your custom behavior. If the user
+of your transition can customize any presentation behavior then you'll want to define a custom
+initializer.
 
-#### Option 2: Subclass UIPresentationController
+> Note: Avoid storing the transition context in your presentation controller. Presentation
+> controllers live for as long as their associated view controller, while the transition context is
+> only valid while a transition is active. Each presentation and dismissal will receive its own
+> unique transition context. Storing the context in the presentation controller would keep the
+> context alive longer than it's meant to.
 
-Start by defining a new presentation controller type:
+Override any `UIPresentationController` methods you'll need in order to implement your motion.
 
 ```swift
 final class MyPresentationController: UIPresentationController {
 }
 ```
 
-Your Transition type must conform to `TransitionWithPresentation` in order to customize
-presentation. Return your custom presentation controller class from the required methods and be sure
-to return the `.custom` presentation style, otherwise UIKit will not use your presentation
-controller.
+#### Step 2: Implement TransitionWithPresentation on your transition
+
+This ensures that your transition implement the required methods for presentation.
+
+Presentation will only be customized if you return `.custom` from the
+`defaultModalPresentationStyle` method and a non-nil `UIPresentationController` subclass from the
+`presentationController` method.
 
 ```swift
 extension VerticalSheetTransition: TransitionWithPresentation {
@@ -255,14 +231,15 @@ extension VerticalSheetTransition: TransitionWithPresentation {
 }
 ```
 
+#### Optional Step 3: Implement Transition on your presentation controller
+
 If your presentation controller needs to animate anything, you can conform to the `Transition`
 protocol in order to receive a `start` invocation each time a transition begins. The presentation
 controller's `start` will be invoked before the transition's `start`.
 
-> Note: Just like your transition, your presentation controller must eventually call
-> `transitionDidEnd` on its context, otherwise your transition will not complete. This is because
-> the transitioning controller waits until all associated transitions have completed before
-> informing UIKit of the view controller transition's completion.
+> Note: It's possible for your presentation controller and your transition to have different ideas
+> of when a transition has completed, so consider which object should be responsible for invoking
+> `transitionDidEnd`. The `Transition` object is usually the one that calls this method.
 
 ```swift
 extension MyPresentationController: Transition {

examples/ContextualExample.swift

@@ -35,10 +35,7 @@ class ContextualExampleViewController: ExampleViewController {
     // Note that in this example we're populating the contextual transition with the tapped view.
     // Our rudimentary transition will animate the context view to the center of the screen from its
     // current location.
-    controller.transitionController.transition = CompositeTransition(transitions: [
-      FadeTransition(target: .foreView),
-      ContextualTransition(contextView: tapGesture.view!)
-    ])
+    controller.transitionController.transition = ContextualTransition(contextView: tapGesture.view!)
 
     present(controller, animated: true)
   }
@@ -100,6 +97,12 @@ private class ContextualTransition: NSObject, Transition {
       context.transitionDidEnd()
     }
 
+    let fadeIn = CABasicAnimation(keyPath: "opacity")
+    fadeIn.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
+    fadeIn.fromValue = 0
+    fadeIn.toValue = 1
+    addAnimationToLayer(fadeIn, context.foreViewController.view.layer)
+
     // We use a snapshot view to accomplish two things:
     // 1) To not affect the context view's state.
     // 2) To allow our context view to appear in front of the fore view controller's view.
@@ -125,8 +128,11 @@ private class ContextualTransition: NSObject, Transition {
                             y: context.foreViewController.view.bounds.midY)
     addAnimationToLayer(shift, snapshotContextView.layer)
 
-    context.compose(with: FadeTransition(target: .target(snapshotContextView),
-                                         style: .fadeOut))
+    let fadeOut = CABasicAnimation(keyPath: "opacity")
+    fadeOut.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
+    fadeOut.fromValue = 1
+    fadeOut.toValue = 0
+    addAnimationToLayer(fadeOut, snapshotContextView.layer)
 
     CATransaction.commit()
   }

examples/CustomPresentationExample.swift

@@ -103,12 +103,12 @@ final class VerticalSheetTransition: NSObject, Transition {
   }
 }
 
-extension VerticalSheetTransition: TransitionWithPresentation, TransitionWithFeasibility {
+extension VerticalSheetTransition: TransitionWithPresentation, TransitionWithFallback {
 
   // We customize the transition going forward but fall back to UIKit for dismissal. Our
   // presentation controller will govern both of these transitions.
-  func canPerformTransition(with context: TransitionContext) -> Bool {
-    return context.direction == .forward
+  func fallbackTransition(with context: TransitionContext) -> Transition? {
+    return context.direction == .forward ? self : nil
   }
 
   // This method is invoked when we assign the transition to the transition controller. The result

examples/FadeExample.m

@@ -27,7 +27,7 @@ - (void)didTap {
 
   // The transition controller is an associated object on all UIViewController instances that
   // allows you to customize the way the view controller is presented. The primary API on the
-  // controller that you'll make use of is the `transitions` property. Setting this property will
+  // controller that you'll make use of is the `transition` property. Setting this property will
   // dictate how the view controller is presented. For this example we've built a custom
   // FadeTransition, so we'll make use of that now:
   viewController.mdm_transitionController.transition = [[FadeTransition alloc] init];

examples/FadeExample.swift

@@ -30,7 +30,7 @@ class FadeExampleViewController: ExampleViewController {
     // controller that you'll make use of is the `transition` property. Setting this property will
     // dictate how the view controller is presented. For this example we've built a custom
     // FadeTransition, so we'll make use of that now:
-    modalViewController.transitionController.transition = FadeTransition(target: .foreView)
+    modalViewController.transitionController.transition = FadeTransition()
 
     // Note that once we assign the transition object to the view controller, the transition will
     // govern all subsequent presentations and dismissals of that view controller instance. If we

examples/NavControllerFadeExample.swift

@@ -31,7 +31,7 @@ class NavControllerFadeExampleViewController: ExampleViewController {
     // controller that you'll make use of is the `transition` property. Setting this property will
     // dictate how the view controller is presented. For this example we've built a custom
     // FadeTransition, so we'll make use of that now:
-    modalViewController.transitionController.transition = FadeTransition(target: .foreView)
+    modalViewController.transitionController.transition = FadeTransition()
 
     cachedNavDelegate = navigationController?.delegate