Introduction

Adding padding programmatically in Android is straightforward, but doing it correctly means thinking about density units, layout direction, and whether the padding should replace or extend the view's existing values. The API itself is simple; most bugs come from passing raw pixel values or from forgetting that start and end padding matter in RTL layouts.

The Core API: setPadding

Every View exposes setPadding(left, top, right, bottom), and the values are measured in pixels.

val textView = TextView(this)
textView.text = "Hello"
textView.setPadding(16, 16, 16, 16)

This works, but the values 16 and 16 are pixels, not density-independent units. That usually makes the layout look too small on high-density screens and inconsistent across devices.

Convert dp to Pixels First

In Android UI code, padding is usually designed in dp, so convert before calling setPadding.

1import android.content.Context
2import android.util.TypedValue
3
4fun Context.dp(value: Int): Int {
5    return TypedValue.applyDimension(
6        TypedValue.COMPLEX_UNIT_DIP,
7        value.toFloat(),
8        resources.displayMetrics
9    ).toInt()
10}
11
12val card = View(this)
13card.setPadding(dp(16), dp(12), dp(16), dp(12))

That keeps your programmatic layout consistent with XML-based layout dimensions.

Use Relative Padding for RTL Safety

If the view should respect right-to-left languages, use setPaddingRelative(start, top, end, bottom) instead of left and right.

val messageView = TextView(this)
messageView.text = "RTL aware padding"
messageView.setPaddingRelative(dp(20), dp(12), dp(20), dp(12))

This is the better default for modern Android apps because start and end follow layout direction automatically.

That difference matters most when the view contains directional content such as icons aligned near the leading edge. A layout that looks correct in English can feel subtly wrong in Arabic or Hebrew if the code hardcodes left and right padding where start and end were intended.

Preserve Existing Padding When Adjusting One Side

A common requirement is to change only one edge while keeping the others unchanged. Read the current padding first, then reapply the full set.

1val button = Button(this)
2
3button.setPadding(
4    button.paddingLeft,
5    button.paddingTop + dp(8),
6    button.paddingRight,
7    button.paddingBottom
8)

If the view uses relative padding, prefer paddingStart and paddingEnd with setPaddingRelative.

Padding Is Not Margin

Padding is inside the view. Margin is outside the view and belongs to the layout parameters. If your goal is to create space between sibling views, changing padding is the wrong tool.

1val params = LinearLayout.LayoutParams(
2    LinearLayout.LayoutParams.MATCH_PARENT,
3    LinearLayout.LayoutParams.WRAP_CONTENT
4)
5params.topMargin = dp(12)
6
7textView.layoutParams = params

Use padding when you want space between the content and the view edges. Use margin when you want space between views.

This distinction also affects backgrounds and click areas. Increasing padding usually enlarges the content inset while preserving the overall view bounds assigned by the parent. Changing margins, by contrast, changes how much space the parent layout reserves around the view.

In custom components, it is also worth checking whether the view already defines internal padding in XML or in a style. A programmatic call to setPadding replaces all four sides at once, so it can unintentionally discard defaults that were added for readability or touch comfort.

Common Pitfalls

• Passing raw pixel values and then wondering why the layout looks inconsistent across screen densities.
• Using setPadding when the layout should really use start and end padding for RTL support.
• Overwriting existing padding when you only meant to adjust one side.
• Using padding to solve an external spacing problem that should be handled with margins instead.
• Forgetting that background drawables and touch targets are affected by padding because the content area changes.

Summary

• Use setPadding or setPaddingRelative to add padding programmatically.
• Convert dp values to pixels before applying them.
• Prefer relative padding for RTL-aware layouts.
• Read existing padding first when you only want to modify one edge.
• Keep padding and margin conceptually separate because they solve different layout problems.