expo-dev-menu 2.1.4 → 3.0.0

package/ios/OverlayContainer/OverlayContainerViewController.swift

@@ -0,0 +1,412 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayViewController.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 12/11/2018.
+//
+
+import UIKit
+
+/// A `OverlayContainerViewController` is a container view controller that manages one or more
+/// child view controllers in an overlay interface.
+///
+/// It defines an area where a view controller, called the overlay view controller,
+/// can be dragged up and down, hiding or revealing the content underneath it.
+///
+/// OverlayContainer uses the last view controller of its viewControllers as the overlay view controller.
+/// It stacks the other view controllers on top of each other, if any, and adds them underneath the overlay view controller.
+open class OverlayContainerViewController: UIViewController {
+
+    /// `OverlayStyle` defines how the overlay view controller will be constrained in the container.
+    public enum OverlayStyle {
+        /// The overlay view controller will not be height-constrained. It will grow and shrink
+        /// as the user drags it up and down.
+        case flexibleHeight
+        /// The overlay view controller will be constrained with a height equal to the highest notch.
+        /// It will be fully visible only when the user has drag it up to this notch.
+        case rigid
+        /// The overlay view controller will be constrained with a height greater or equal to the highest notch.
+        /// Its height will be expanded if the overlay goes beyond the highest notch.
+        case expandableHeight
+    }
+
+    /// The delegate of the container.
+    weak open var delegate: OverlayContainerViewControllerDelegate? {
+        set {
+            configuration.delegate = newValue
+            configuration.invalidateOverlayMetrics()
+            setNeedsOverlayContainerHeightUpdate()
+        }
+        get {
+            return configuration.delegate
+        }
+    }
+
+    /// The view controllers displayed.
+    open var viewControllers: [UIViewController] = [] {
+        didSet {
+            guard isViewLoaded else { return }
+            oldValue.forEach { removeChild($0) }
+            loadOverlayViews()
+            setNeedsStatusBarAppearanceUpdate()
+        }
+    }
+
+    /// The overlay view controller
+    open var topViewController: UIViewController? {
+        return viewControllers.last
+    }
+
+    open override var childForStatusBarStyle: UIViewController? {
+        return topViewController
+    }
+
+    /// The scroll view managing the overlay translation.
+    weak open var drivingScrollView: UIScrollView? {
+        didSet {
+            guard drivingScrollView !== oldValue else { return }
+            guard isViewLoaded else { return }
+            loadTranslationDrivers()
+        }
+    }
+
+    /// The height of the area where the overlay view controller can be dragged up and down.
+    /// It will only be valid once the container view is laid out or in the delegate callbacks.
+    open var availableSpace: CGFloat {
+        return view.frame.height
+    }
+
+    /// The style of the container.
+    public let style: OverlayStyle
+
+    private lazy var overlayPanGesture: OverlayTranslationGestureRecognizer = self.makePanGesture()
+    private lazy var overlayContainerView = OverlayContainerView()
+    private lazy var overlayTranslationView = OverlayTranslationView()
+    private lazy var overlayTranslationContainerView = OverlayTranslationContainerView()
+    private lazy var groundView = GroundView()
+
+    private var overlayContainerViewStyleConstraint: NSLayoutConstraint?
+    private var translationHeightConstraint: NSLayoutConstraint?
+
+    private lazy var configuration = makeConfiguration()
+
+    private var needsOverlayContainerHeightUpdate = true
+
+    private var previousSize: CGSize = .zero
+    private var translationController: HeightConstraintOverlayTranslationController?
+    private var translationDrivers: [OverlayTranslationDriver] = []
+
+    // (gz) 2020-08-11 Uses to determine whether we can safely call `presentationController` or not.
+    // See issue #72
+    private var isPresentedInsideAnOverlayContainerPresentationController = false
+
+    // MARK: - Life Cycle
+
+    /// Creates an instance with the specified `style`.
+    ///
+    /// - parameter style: The style used by the container. The default value is `expandableHeight`.
+    ///
+    /// - returns: The new `OverlayContainerViewController` instance.
+    public init(style: OverlayStyle = .expandableHeight) {
+        self.style = style
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    public required init?(coder aDecoder: NSCoder) {
+        self.style = .flexibleHeight
+        super.init(coder: aDecoder)
+    }
+
+    // MARK: - UIViewController
+
+    open override func loadView() {
+        view = PassThroughView()
+        view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        loadContainerViews()
+        loadOverlayViews()
+    }
+
+    open override func viewDidLoad() {
+        super.viewDidLoad()
+        setUpPanGesture()
+    }
+
+    open override func viewWillLayoutSubviews() {
+        // (gz) 2019-06-10 According to the documentation, the default implementation of
+        // `viewWillLayoutSubviews` does nothing.
+        // Nethertheless in its `Changing Constraints` Guide, Apple recommends to call it.
+        defer {
+            super.viewWillLayoutSubviews()
+        }
+        let hasNewHeight = previousSize.height != view.bounds.size.height
+        let hasPendingTranslation = translationController?.hasPendingTranslation() == true
+        guard needsOverlayContainerHeightUpdate || hasNewHeight else { return }
+        needsOverlayContainerHeightUpdate = false
+        previousSize = view.bounds.size
+        if hasNewHeight {
+            configuration.invalidateOverlayMetrics()
+        }
+        if hasNewHeight && !hasPendingTranslation {
+            translationController?.scheduleOverlayTranslation(
+                .toLastReachedNotchIndex,
+                velocity: .zero,
+                animated: false
+            )
+        }
+        configuration.requestOverlayMetricsIfNeeded()
+        performDeferredTranslations()
+    }
+
+    // MARK: - Internal
+
+    func overlayContainerPresentationTransitionWillBegin() {
+        isPresentedInsideAnOverlayContainerPresentationController = true
+    }
+
+    func overlayContainerDismissalTransitionDidEnd() {
+        isPresentedInsideAnOverlayContainerPresentationController = false
+    }
+
+    // MARK: - Public
+
+    /// Moves the overlay view controller to the specified notch.
+    ///
+    /// - parameter index: The index of the target notch.
+    /// - parameter animated: Defines either the transition should be animated or not.
+    /// - parameter completion: The block to execute after the translation finishes.
+    ///   This block has no return value and takes no parameters. You may specify nil for this parameter.
+    ///
+    open func moveOverlay(toNotchAt index: Int, animated: Bool, completion: (() -> Void)? = nil) {
+        loadViewIfNeeded()
+        translationController?.scheduleOverlayTranslation(
+            .toIndex(index),
+            velocity: .zero,
+            animated: animated,
+            completion: completion
+        )
+        setNeedsOverlayContainerHeightUpdate()
+    }
+
+    /// Invalidates the current container notches.
+    ///
+    /// This method does not reload the notch heights immediately. The changes are scheduled to the next layout pass.
+    /// By default, the overlay container will use its target notch policy to determine where to go
+    /// and animates the translation.
+    /// Use `moveOverlay(toNotchAt:animated:completion:)` to override this behavior.
+    ///
+    open func invalidateNotchHeights() {
+        guard isViewLoaded else { return }
+        configuration.invalidateOverlayMetrics()
+        translationController?.scheduleOverlayTranslation(
+            .basedOnTargetPolicy,
+            velocity: .zero,
+            animated: true
+        )
+        setNeedsOverlayContainerHeightUpdate()
+    }
+
+    // MARK: - Private
+
+    private func loadContainerViews() {
+        view.addSubview(groundView)
+        groundView.pinToSuperview()
+        view.addSubview(overlayTranslationContainerView)
+        overlayTranslationContainerView.pinToSuperview()
+        overlayTranslationContainerView.addSubview(overlayTranslationView)
+        overlayTranslationView.addSubview(overlayContainerView)
+        overlayTranslationView.pinToSuperview(edges: [.bottom, .left, .right])
+        overlayContainerView.pinToSuperview(edges: [.left, .top, .right])
+        translationHeightConstraint = overlayTranslationView.heightAnchor.constraint(equalToConstant: 0)
+        switch style {
+        case .flexibleHeight:
+            overlayContainerViewStyleConstraint = overlayContainerView.bottomAnchor.constraint(
+                equalTo: overlayTranslationView.bottomAnchor
+            )
+        case .rigid:
+            overlayContainerViewStyleConstraint = overlayContainerView.heightAnchor.constraint(
+                equalToConstant: 0
+            )
+        case .expandableHeight:
+            overlayContainerViewStyleConstraint = overlayContainerView.heightAnchor.constraint(
+                equalToConstant: 0
+            )
+            overlayContainerViewStyleConstraint?.priority = .defaultHigh
+            let bottomConstraint = overlayContainerView.bottomAnchor.constraint(
+                greaterThanOrEqualTo: overlayTranslationView.bottomAnchor
+            )
+            bottomConstraint.isActive = true
+        }
+        loadTranslationController()
+    }
+
+    private func loadTranslationController() {
+        guard let translationHeightConstraint = translationHeightConstraint else { return }
+        translationController = HeightConstraintOverlayTranslationController(
+            translationHeightConstraint: translationHeightConstraint,
+            configuration: configuration
+        )
+        translationController?.delegate = self
+        translationController?.scheduleOverlayTranslation(
+            .toIndex(0),
+            velocity: .zero,
+            animated: false
+        )
+    }
+
+    private func loadOverlayViews() {
+        guard !viewControllers.isEmpty else { return }
+        groundView.isHidden = viewControllers.count == 1
+        var truncatedViewControllers = viewControllers
+        truncatedViewControllers.popLast().flatMap { addChild($0, in: overlayContainerView) }
+        truncatedViewControllers.forEach { addChild($0, in: groundView) }
+        loadTranslationDrivers()
+    }
+
+    private func loadTranslationDrivers() {
+        guard let translationController = translationController,
+            let overlayController = topViewController else {
+                return
+        }
+        translationDrivers.forEach { $0.clean() }
+        translationDrivers.removeAll()
+        var drivers: [OverlayTranslationDriver] = []
+        let panGestureDriver = PanGestureOverlayTranslationDriver(
+            translationController: translationController,
+            panGestureRecognizer: overlayPanGesture
+        )
+        drivers.append(panGestureDriver)
+        let scrollView = drivingScrollView ?? configuration.scrollView(drivingOverlay: overlayController)
+        if let scrollView = scrollView {
+            overlayPanGesture.drivingScrollView = scrollView
+            let driver = ScrollViewOverlayTranslationDriver(
+                translationController: translationController,
+                scrollView: scrollView
+            )
+            drivers.append(driver)
+        }
+        translationDrivers = drivers
+    }
+
+    private func setNeedsOverlayContainerHeightUpdate() {
+        needsOverlayContainerHeightUpdate = true
+        viewIfLoaded?.setNeedsLayout()
+    }
+
+    private func updateOverlayContainerConstraints() {
+        switch style {
+        case .flexibleHeight:
+            overlayContainerViewStyleConstraint?.constant = 0
+        case .rigid, .expandableHeight:
+            overlayContainerViewStyleConstraint?.constant = configuration.maximumNotchHeight
+        }
+        translationHeightConstraint?.isActive = true
+        overlayContainerViewStyleConstraint?.isActive = true
+    }
+
+    private func performDeferredTranslations() {
+        translationController?.performDeferredTranslations()
+    }
+
+    private func setUpPanGesture() {
+        view.addGestureRecognizer(overlayPanGesture)
+    }
+
+    private func makeConfiguration() -> OverlayContainerConfigurationImplementation {
+        return OverlayContainerConfigurationImplementation(
+            overlayContainerViewController: self
+        )
+    }
+
+    private func makePanGesture() -> OverlayTranslationGestureRecognizer {
+        return OverlayTranslationGestureRecognizer()
+    }
+}
+
+extension OverlayContainerViewController: HeightConstraintOverlayTranslationControllerDelegate {
+
+    private var overlayPresentationController: OverlayContainerPresentationController? {
+        guard isPresentedInsideAnOverlayContainerPresentationController else { return nil }
+        return oc_findPresentationController(OverlayContainerPresentationController.self)
+    }
+
+    // MARK: - HeightOverlayTranslationControllerDelegate
+
+    func translationController(_ translationController: OverlayTranslationController,
+                               didMoveOverlayToNotchAt index: Int) {
+        guard let controller = topViewController else { return }
+        delegate?.overlayContainerViewController(self, didMoveOverlay: controller, toNotchAt: index)
+        overlayPresentationController?.overlayContainerViewController(
+            self,
+            didMoveOverlay: controller,
+            toNotchAt: index
+        )
+    }
+
+    func translationController(_ translationController: OverlayTranslationController,
+                               willMoveOverlayToNotchAt index: Int) {
+        guard let controller = topViewController else { return }
+        delegate?.overlayContainerViewController(self, willMoveOverlay: controller, toNotchAt: index)
+        overlayPresentationController?.overlayContainerViewController(
+            self,
+            willMoveOverlay: controller,
+            toNotchAt: index
+        )
+    }
+
+    func translationControllerWillStartDraggingOverlay(_ translationController: OverlayTranslationController) {
+        guard let controller = topViewController else { return }
+        delegate?.overlayContainerViewController(
+            self,
+            willStartDraggingOverlay: controller
+        )
+        overlayPresentationController?.overlayContainerViewController(
+            self,
+            willStartDraggingOverlay: controller
+        )
+    }
+
+    func translationController(_ translationController: OverlayTranslationController,
+                               willEndDraggingAtVelocity velocity: CGPoint) {
+        guard let controller = topViewController else { return }
+        delegate?.overlayContainerViewController(
+            self,
+            willEndDraggingOverlay: controller,
+            atVelocity: velocity
+        )
+        overlayPresentationController?.overlayContainerViewController(
+            self,
+            willEndDraggingOverlay: controller,
+            atVelocity: velocity
+        )
+    }
+
+    func translationController(_ translationController: OverlayTranslationController,
+                               willTranslateOverlayWith transitionCoordinator: OverlayContainerTransitionCoordinator) {
+        guard let controller = topViewController else { return }
+        if transitionCoordinator.isAnimated {
+            overlayTranslationContainerView.layoutIfNeeded()
+        }
+        transitionCoordinator.animate(alongsideTransition: { [weak self] context in
+            self?.updateOverlayContainerConstraints()
+            self?.overlayTranslationContainerView.layoutIfNeeded()
+        }, completion: nil)
+        delegate?.overlayContainerViewController(
+            self,
+            willTranslateOverlay: controller,
+            transitionCoordinator: transitionCoordinator
+        )
+        overlayPresentationController?.overlayContainerViewController(
+            self,
+            willTranslateOverlay: controller,
+            transitionCoordinator: transitionCoordinator
+        )
+    }
+
+    func translationControllerDidScheduleTranslations(_ translationController: OverlayTranslationController) {
+        setNeedsOverlayContainerHeightUpdate()
+    }
+
+    func overlayViewController(for translationController: OverlayTranslationController) -> UIViewController? {
+        return topViewController
+    }
+}

package/ios/OverlayContainer/OverlayContainerViewControllerDelegate.swift

@@ -0,0 +1,155 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerViewControllerDelegate.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 23/11/2018.
+//
+
+import UIKit
+
+/// The container delegate is responsible for defining the aspect and the behavior of the container.
+public protocol OverlayContainerViewControllerDelegate: AnyObject {
+
+    /// Asks the delegate for the number of notches in the container.
+    /// **Required**.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    ///
+    /// - returns: The number of notches in `containerViewController`.
+    func numberOfNotches(in containerViewController: OverlayContainerViewController) -> Int
+
+    /// Asks the delegate for the height of a notch in a specified location.
+    /// **Required**.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter index: The index that locates the notch.
+    /// - parameter availableSpace: The height of the zone defined by the overlay.
+    ///
+    /// - returns: A nonnegative floating-point value that specifies the height that notch should be.
+    ///
+    /// - attention: The notches must be ordered from the smallest one (index 0) to the highest one
+    /// and must not exceed the available space.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        heightForNotchAt index: Int,
+                                        availableSpace: CGFloat) -> CGFloat
+
+    /// Asks the delegate for a scroll view driving the overlay view controller translation.
+    ///
+    /// The container view controller can coordinate the scrolling of a scroll view
+    /// to the overlay view controller translation. The overlay will be moved up & down as the user scrolls.
+    /// The content offset of the scroll view will be adjusted accordingly.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    ///
+    /// - returns: A scroll view to use as a translation driver.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        scrollViewDrivingOverlay overlayViewController: UIViewController) -> UIScrollView?
+
+    /// Asks the delegate if the container should drag the overlay view controller
+    /// when the user starts a pan gesture at the specified location.
+    ///
+    /// The container view controller detects pan gestures on its own view.
+    /// It calls this method each time a pan gesture is detected.
+    /// If the gesture begins in the scroll view specified in `overlayContainerViewController(_:, scrollViewDrivingOverlay:)`,
+    /// the gesture is aborted and this method is not called.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter point: The starting point of the gesture.
+    /// - parameter coordinateSpace: The coordinate space of point.
+    ///
+    /// - returns: `true` if the translation should start or `false` if it should not.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        shouldStartDraggingOverlay overlayViewController: UIViewController,
+                                        at point: CGPoint,
+                                        in coordinateSpace: UICoordinateSpace) -> Bool
+
+    /// Tells the delegate when the user is about to start dragging the overlay view controller.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willStartDraggingOverlay overlayViewController: UIViewController)
+
+    /// Tells the delegate when the user finishs dragging the overlay view controller with the specified velocity.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter velocity: The overlay velocity at the moment the touch was released.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willEndDraggingOverlay overlayViewController: UIViewController,
+                                        atVelocity velocity: CGPoint)
+
+    /// Tells the delegate when the container is about to move the overlay view controller to the specified notch.
+    ///
+    /// In some cases, the overlay view controller may not successfully reach the specified notch.
+    /// If the user cancels the translation for instance. Use `overlayContainerViewController(_:didMove:toNotchAt:)`
+    /// if you need to be notified each time the translation succeeds.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter index: The notch index the overlay view controller is about to reach.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willMoveOverlay overlayViewController: UIViewController,
+                                        toNotchAt index: Int)
+
+    /// Tells the delegate when the container has moved the overlay view controller to the specified notch.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter index: The notch index the overlay view controller has reached.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        didMoveOverlay overlayViewController: UIViewController,
+                                        toNotchAt index: Int)
+
+    /// Tells the delegate whenever the overlay view controller is about to be translated.
+    ///
+    /// The delegate typically implements this method to coordinate changes alongside
+    /// the overlay view controller translation.
+    ///
+    /// For instance, the container may call this method for the following reasons:
+    ///
+    /// - The user is dragging the overlay view controller
+    /// - The user finishs dragging the overlay view controller and the container is about to move
+    /// to the notch specified by the current target notch policy
+    /// - You called `moveOverlay(toNotchAt:animated:completion:)`
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter transitionCoordinator: The transition coordinator object associated with the translation.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willTranslateOverlay overlayViewController: UIViewController,
+                                        transitionCoordinator: OverlayContainerTransitionCoordinator)
+
+    /// Asks the delegate for a translation function when dragging the specified view controller.
+    ///
+    /// The function is only used for translation based on the container pan gesture recognizer.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    ///
+    /// - returns: A overlay translation function.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        overlayTranslationFunctionForOverlay overlayViewController: UIViewController) -> OverlayTranslationFunction?
+
+    /// Asks the delegate for an object providing the translation end animator.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    ///
+    /// - returns: A object implementing the `OverlayTransitioningDelegate` protocol.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        transitioningDelegateForOverlay overlayViewController: UIViewController) -> OverlayTransitioningDelegate?
+
+    /// Asks the delegate if the container can reach the specified notch.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter index: The index locating the notch.
+    /// - parameter overlayViewController: The overlay view controller.
+    ///
+    /// - returns: `true` if the overlay is allowed to reach the specified notch index or `false` if it should not.
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        canReachNotchAt index: Int,
+                                        forOverlay overlayViewController: UIViewController) -> Bool
+}

package/ios/OverlayContainer/OverlayTransitioningDelegate.swift

@@ -0,0 +1,67 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayTransitioningDelegate.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+/// A protocol that provides contextual information on the current overlay translation.
+///
+/// Do not adopt this protocol in your own classes, use the one provided in `OverlayTranslationTargetNotchPolicy`.
+public protocol OverlayContainerContextTargetNotchPolicy: OverlayContainerTransitionContext {
+    /// The manipulated child view controller.
+    var overlayViewController: UIViewController { get }
+}
+
+/// A protocol that provides contextual information on the current overlay translation.
+///
+/// Do not adopt this protocol in your own classes, use the one provided in `OverlayAnimatedTransitioning`.
+public protocol OverlayContainerContextTransitioning: OverlayContainerTransitionContext {
+    /// The manipulated child view controller.
+    var overlayViewController: UIViewController { get }
+    /// The expected notch index once the animations ended.
+    var targetNotchIndex: Int { get }
+    /// The expected translation height once the animation ended.
+    var targetNotchHeight: CGFloat { get }
+}
+
+/// A protocol that manages the container behavior once the user finishes dragging.
+///
+/// Adopt this protocol to provide your own translation behavior.
+public protocol OverlayTransitioningDelegate: AnyObject {
+    /// Returns the target notch policy for the specified child view controller.
+    func overlayTargetNotchPolicy(for overlayViewController: UIViewController) -> OverlayTranslationTargetNotchPolicy?
+    /// Returns the animation controller for the specified child view controller.
+    func animationController(for overlayViewController: UIViewController) -> OverlayAnimatedTransitioning?
+}
+
+/// A protocol that provides the expected notch index once the user finishes dragging.
+///
+/// Adopt this protocol to provide your own policy. You can also use the provided
+/// implementations like `RushingForwardTargetNotchPolicy`.
+public protocol OverlayTranslationTargetNotchPolicy {
+    /// Returns the expected notch index based on the specified context.
+    func targetNotchIndex(using context: OverlayContainerContextTargetNotchPolicy) -> Int
+}
+
+/// A protocol that provides the animation controllers once the user finishes dragging.
+///
+/// Adopt this protocol to perform your own translation animations. You can also use the provided
+/// implementations like `SpringOverlayTranslationAnimationController`.
+public protocol OverlayAnimatedTransitioning {
+    /// Returns the animator that will animate the end of the translation.
+    func interruptibleAnimator(using context: OverlayContainerContextTransitioning) -> UIViewImplicitlyAnimating
+}
+
+public extension OverlayTransitioningDelegate {
+
+    func overlayTargetNotchPolicy(for overlayViewController: UIViewController) -> OverlayTranslationTargetNotchPolicy? {
+        nil
+    }
+
+    func animationController(for overlayViewController: UIViewController) -> OverlayAnimatedTransitioning? {
+        nil
+    }
+}

package/ios/OverlayContainer/OverlayTranslationFunction.swift

@@ -0,0 +1,29 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  PassThroughView.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+/// A protocol that provides information about an in-progress translation.
+/// Do not adopt this protocol in your own classes. Use the one provided by the `OverlayTranslationFunction`.
+public protocol OverlayTranslationParameters {
+    /// The mininum translation height
+    var minimumHeight: CGFloat { get }
+    /// The maximum translation height
+    var maximumHeight: CGFloat { get }
+    /// The user finger translation
+    var translation: CGFloat { get }
+}
+
+/// A `OverlayTranslationFunction` defines the relation between the user finger translation
+/// and the actual overlay translation.
+///
+/// Adopt this protocol to tweak the native translation behavior. You can also use the provided
+/// implementations like `RubberBandOverlayTranslationFunction`.
+public protocol OverlayTranslationFunction {
+    /// Returns the expected translation based on the specified parameters.
+    func overlayTranslationHeight(using parameters: OverlayTranslationParameters) -> CGFloat
+}