Introduction

A left-to-right slide animation in Android usually means animating a view or a whole screen by changing its horizontal position over time. The modern way to do this is with property animation, typically through translationX, because it is more flexible and accurate than the old view animation system.

The exact implementation depends on what is moving: a single view, a fragment, or an activity transition. The animation principle is the same, but the API entry point differs.

Animate a View with translationX

For an individual view, use property animation.

1View card = findViewById(R.id.card);
2card.setTranslationX(-300f);
3card.animate()
4    .translationX(0f)
5    .setDuration(300)
6    .start();

This makes the view start slightly off-screen to the left and slide into its resting position.

Because translationX is a real property, the final position is reflected in layout rendering after the animation.

XML Animation Resource Example

If you prefer reusable XML animation resources, define one under res/anim/slide_in_right.xml.

1<translate xmlns:android="http://schemas.android.com/apk/res/android"
2    android:fromXDelta="-100%p"
3    android:toXDelta="0"
4    android:duration="300" />

Then apply it:

Animation animation = AnimationUtils.loadAnimation(this, R.anim.slide_in_right);
view.startAnimation(animation);

This older style still works, but property animation is usually the better default for new UI code.

Activity Transition Example

If you want one activity to slide in from left to right, use transition overrides.

startActivity(new Intent(this, NextActivity.class));
overridePendingTransition(R.anim.slide_in_right, R.anim.stay_still);

And define a matching stay_still.xml if needed:

1<alpha xmlns:android="http://schemas.android.com/apk/res/android"
2    android:fromAlpha="1.0"
3    android:toAlpha="1.0"
4    android:duration="300" />

This is useful for screen-level navigation effects.

Fragment and Navigation Context

If you use fragments or Jetpack Navigation, prefer transition APIs that integrate with those systems instead of manually animating root views every time.

The more structured the UI stack is, the more valuable it is to keep animation definitions near the navigation behavior rather than scattered across click handlers.

Interpolators Matter

Animation quality depends on more than duration. Interpolators shape how the motion feels.

1card.animate()
2    .translationX(0f)
3    .setDuration(300)
4    .setInterpolator(new DecelerateInterpolator())
5    .start();

A decelerate interpolator often feels more natural for a sliding entrance than a perfectly linear motion.

XML vs. Property Animation Tradeoff

XML animation resources are convenient when designers or multiple screens reuse the same motion pattern. Property animation is usually better when the motion distance depends on runtime values such as measured view width, device size, or gesture state.

In practice, many apps use both: XML for simple standard transitions and property animation for interactive or data-dependent movement.

Keep Motion Consistent with Navigation

A left-to-right animation implies a directional story to the user. If one screen slides in from the left and the next screen uses a conflicting direction for a similar action, the UI can feel inconsistent even if each animation works technically. Motion should reinforce the navigation model rather than exist only as decoration.

Common Pitfalls

The biggest mistake is using the old view animation APIs when you actually need the view's final position to change. Old-style animations can move pixels visually without updating the underlying property state.

Another common issue is using hard-coded pixel distances that look wrong on different screen sizes. Prefer percentages in XML or compute distances relative to the view or screen width.

People also animate without considering navigation context. A good activity transition and a good in-view animation are not necessarily the same thing.

Finally, avoid excessive duration. Slide animations usually feel best when they are short and purposeful.

Summary

• Use property animation with translationX for most modern Android slide effects.
• XML translate animations still work, but property animation is usually more reliable.
• Use overridePendingTransition for activity-level slide transitions.
• Match the animation API to whether you are moving a view, fragment, or full screen.
• Interpolators affect perceived smoothness as much as duration does.
• Prefer responsive distances over hard-coded pixel values.