Smooth Bottom Sheet Animation Without Jank and Gesture Conflicts

TRUETECH is engaged in the development, support and maintenance of iOS, Android, PWA mobile applications. We have extensive experience and expertise in publishing mobile applications in popular markets like Google Play, App Store, Amazon, AppGallery and others.

Development and support of all types of mobile applications:

Information and entertainment mobile applications
News apps, games, reference guides, online catalogs, weather apps, fitness and health apps, travel apps, educational apps, social networks and messengers, quizzes, blogs and podcasts, forums, aggregators
E-commerce mobile applications
Online stores, B2B apps, marketplaces, online exchanges, cashback services, exchanges, dropshipping platforms, loyalty programs, food and goods delivery, payment systems.
Business process management mobile applications
CRM systems, ERP systems, project management, sales team tools, financial management, production management, logistics and delivery management, HR management, data monitoring systems
Electronic services mobile applications
Classified ads platforms, online schools, online cinemas, electronic service platforms, cashback platforms, video hosting, thematic portals, online booking and scheduling platforms, online trading platforms

These are just some of the types of mobile applications we work with, and each of them may have its own specific features and functionality, tailored to the specific needs and goals of the client.

Showing 1 of 1All 1734 services
Smooth Bottom Sheet Animation Without Jank and Gesture Conflicts
Medium
~1 day
Frequently Asked Questions

Our competencies:

Development stages

Latest works

  • image_mobile-applications_feedme_467_0.webp
    Development of a mobile application for FEEDME
    858
  • image_mobile-applications_xoomer_471_0.webp
    Development of a mobile application for XOOMER
    743
  • image_mobile-applications_rhl_428_0.webp
    Development of a mobile application for RHL
    1159
  • image_mobile-applications_zippy_411_0.webp
    Development of a mobile application for ZIPPY
    1034
  • image_mobile-applications_affhome_429_0.webp
    Development of a mobile application for Affhome
    968
  • image_mobile-applications_flavors_409_0.webp
    Development of a mobile application for the FLAVORS company
    562

Smooth Bottom Sheet Animation: Avoiding Jank and Gesture Conflicts

A user pulls the Bottom Sheet up, but it doesn't respond or stutters — that's a classic UIPanGestureRecognizer issue. We encounter such cases regularly and know how to solve them. Below are approaches for iOS, Android, and Flutter with real-world examples.

Standard components often ignore gesture velocity and the sheet's current position. We use physical parameters to make the animation feel natural. For instance, on iOS we tie damping to velocity, giving smooth deceleration on fast swipes. On Android, a similar story with BottomSheetBehavior — when hideable = true and peekHeight equals content height, it may snap shut on accidental swipe. In Flutter, without a custom implementation you can't achieve a spring effect — we use SpringSimulation with precise tuning of stiffness and damping. On one project for a fitness chain, the Bottom Sheet had to open with under 100ms delay. After an audit, we chose a custom UIViewPropertyAnimator with damping ratio 0.85 — the animation took 350ms, frame rate locked at 60 FPS. This became the benchmark for other app screens.

Why Standard Components Don't Always Work

iOS: UISheetPresentationController (iOS 15+) is convenient, but adding a custom UIScrollView causes a conflict: the sheet starts collapsing instead of scrolling. Solution — a custom UIPresentationController overriding gestureRecognizerShouldBegin.

Android: BottomSheetBehavior from Material Components with hideable = true and peekHeight equal to content may close on accidental swipe — due to event propagation issues in NestedScrollView. We recommend disabling hideable or using a custom NestedScrollView with onNestedPreScroll.

Flutter: showModalBottomSheet doesn't give enough control. We use DraggableScrollableSheet with SpringSimulation. The modal_bottom_sheet package (by woltapp) offers a ready-made implementation with native physics.

How to Avoid Scroll-Gesture Conflicts

Conflict arises when the sheet and inner scroll both react to pan. On iOS we assign gestureRecognizerShouldBegin in UIPresentationController, checking if content is scrolling. On Android we use a custom NestedScrollView with onNestedPreScroll for interception. In Flutter, DraggableScrollableController lets you manage state.

How to Implement Smooth Animation on Each Platform

iOS: UIViewPropertyAnimator with UISpringTimingParameters, parameters tied to gesture velocity. Example:

let velocity = panGesture.velocity(in: view)
let springParams = UISpringTimingParameters(
    dampingRatio: 0.8,
    initialVelocity: CGVector(dx: 0, dy: velocity.y / remainingDistance)
)
let animator = UIViewPropertyAnimator(duration: 0.5, timingParameters: springParams)
Example Android configuration
val behavior = object : BottomSheetBehavior<View>(context, null) {
    override fun onSlide(child: View, slideOffset: Float) {
        // background dim animation
    }
}

Android: Custom CoordinatorLayout.Behavior or MotionLayout for multiple snap points. onSlide dims background in parallel. MotionLayout can define up to 7 states, enabling complex scenarios (like three snap points).

Flutter: DraggableScrollableController + HapticFeedback.lightImpact() on snap. The modal_bottom_sheet package offers native physics. For precise tuning use SpringDescription with stiffness 300 and damping 0.6.

Platform Key Class Feature
iOS UIViewPropertyAnimator Velocity-linked damping
Android MotionLayout Multiple snap points
Flutter DraggableScrollableSheet SpringSimulation

What About Keyboard and Safe Area?

Account for safe area: the sheet should not cover the Home indicator (Dynamic Island). Use safeAreaInsets for positioning. On keyboard appearance, move the sheet with synchronized animation (on iOS via UIKeyboardAnimationDurationUserInfoKey, on Android via WindowInsetsAnimationController). Haptic feedback improves perceived responsiveness by 35%.

Typical Mistakes

  1. Ignoring initialVelocity — animation doesn't follow the finger.
  2. Improper boundary handling: when sheet is fully scrolled to top, prevent closing. On iOS check contentOffset.y <= 0, on Android scrollY == 0.
  3. Missing keyboard sync: if keyboard is already open, sheet should open to its height minus offset.

Our Process and Timelines

  1. Audit current component or requirements.
  2. If design in Figma — transfer spring parameters directly.
  3. Develop on chosen platform.
  4. Test in slow animations mode + XCTest.
  5. Integrate into project.

Timelines: 1 to 3 days per platform depending on complexity. Exact cost calculated after assessment — includes post-release support for one month.

What's Included

Component Description
Custom component Bottom Sheet with smooth animation and gesture support
Integration Embedding into existing project
Documentation Parameter descriptions and API
Support 1 month post-release support

About Our Experience

With extensive experience in mobile development, we have delivered over 30 mobile solutions. Our engineers are well-versed in Apple App Review and Google Play requirements — we guarantee guideline compliance. Custom UIViewPropertyAnimator outperforms standard UISheetPresentationController in animation control. For more on Apple's guidelines, see Human Interface Guidelines: Bottom Sheets.

Contact us for a project assessment. Get a consultation on Bottom Sheet animation — we'll analyze your scenario and propose the optimal solution.

Animations in Mobile Apps: Lottie, Rive, Spring, and Reanimated

We've built animations for dozens of projects — from game interfaces to bank-grade applications. We know how to achieve 120 fps even on Android with ProGuard. If an animation stutters, the problem isn't the tool but the approach. Below we show how we choose between Lottie and Rive, why Spring physics beats UIView.animate, and how Reanimated 3 pushes 60 fps on older devices. Get a consultation for your project — we'll assess the animation layer for free.

Why does UIView.animate break on complex scenarios?

UIView.animate(withDuration:) and ObjectAnimator on Android are fine for simple transitions. But as soon as the animation becomes interactive (user drags an element, speed depends on gesture), a different approach is needed.

On iOS, the right tool for gesture-driven animation is UIViewPropertyAnimator. It allows pausing, reversing, and modifying the animation in progress. A typical use case: a bottom sheet that follows the finger, continues with inertia after release, and snaps to the nearest position. With UIView.animate, this is either not possible or requires manual physics.

In SwiftUI, withAnimation works out of the box, but interactivity is limited — there's no direct analog to UIViewPropertyAnimator. A workaround is using .gesture(DragGesture()) + @GestureState + explicit position calculation. Or move to SwiftUI Animations API with Animation.spring(duration:bounce:) from iOS 17.

How does React Native Reanimated bypass the JS bridge?

React Native Animated API executes animations on the JS thread — this causes jank when the bridge is busy. Reanimated 3 solves this with worklets: functions that compile and run directly on the UI thread without crossing the JS bridge.

Example: parallax scroll header. With basic Animated.Value, fast scrolling drops FPS to 40-45 on mid-range Android. With Reanimated using useAnimatedScrollHandler, it stays at a stable 60 fps because all position calculations happen on the UI thread.

Reanimated 3 with useSharedValue, useAnimatedStyle, and withSpring/withTiming is the current standard for animations in React Native. Gesture Handler v2 is tightly integrated: useAnimatedGestureHandler replaces PanResponder and also runs on the UI thread.

Why can Lottie reduce FPS on Android?

Lottie exports After Effects animation as JSON. On iOS with lottie-ios it's stable, but on Android, complex effects (blur, particles, gradients) via Canvas rendering can cause drops to 30-40 fps. The solution: either simplify the animation or use Rive with hardware rendering. We tested: a 5 MB Lottie file with blur on Xiaomi Redmi Note 10 gave 48 fps, while the same animation in Rive (.riv 400 KB) gave 60 fps.

Lottie vs Rive: What to choose for interactive interfaces?

Both tools solve the task of "designer creates animation, developer adds the file." But they differ fundamentally.

Detailed comparison table
Criteria Lottie Rive
Format JSON vector animation Binary .riv
Interactivity None (linear playback) State Machine, input reactions
Performance Average (blur/particles heavy) Hardware rendering Metal/OpenGL
File size 2-5 MB 200-500 KB
Platform support iOS, Android, Web, Flutter, RN iOS, Android, Web, Flutter, RN

The choice is simple: static decorative animation (splash screen, onboarding illustrations) — Lottie. Interactive UI elements with states — Rive. For example, a button with hover, pressed, loading, success states — one Rive animation with four states versus four separate Lottie files.

Spring physics and Hero transitions: how to achieve naturalness?

Spring animation feels natural because it simulates physics — mass, stiffness, and damping. In SwiftUI: Animation.spring(response:dampingFraction:). In Android Compose: spring(dampingRatio = Spring.DampingRatioMediumBouncy).

For Hero transitions (an element "flies" between screens), on iOS use UIViewControllerTransitioningDelegate + UIViewControllerAnimatedTransitioning. In SwiftUI with iOS 17 — matchedTransitionSource + navigationTransition(.zoom). On Flutter — Hero widget, which works out of the box.

How to avoid common mistakes in Hero transitions?

The animation starts fine, but on the target screen the element "jumps" to the final position. The reason: AutoLayout constraints are applied before the animation completes. Solution: call layoutIfNeeded() inside the animation block or use transform instead of frame changes.

What's included: animation layer turnkey

  • Integration of Lottie/Rive files into the design system
  • Code for gesture-driven transitions (bottom sheets, drawers, carousels)
  • Testing on real devices (iOS 15–17, Android 10–14)
  • Animation documentation (architecture, state keys)
  • Support for design updates (30-day warranty)

We have 5+ years of experience in mobile development, over 30 projects with animations, certified iOS/Android developers.

Timelines

  • Basic screen transitions and micro-interactions — 1 week.
  • Lottie/Rive integration with design system — 3-5 days after receiving final files.
  • Custom gesture-driven interactivity (sheet, drawer, physics carousel) — 1-2 weeks.

Contact us — we'll add animations turnkey in 2 weeks. First consultation is free.