Jetpack Compose Button with gradient background?

Compose 1.0.0-alpha10

You could do someething like this:

@Composable
fun GradientButton(
    text: String,
    gradient : Brush,
    modifier: Modifier = Modifier,
    onClick: () -> Unit = { },
) {
    Button(
        modifier = modifier,
        colors = ButtonDefaults.buttonColors(backgroundColor = Color.Transparent),
        contentPadding = PaddingValues(),
        onClick = { onClick() },
    ) {
        Box(
            modifier = Modifier
                .background(gradient)
                .then(modifier),
            contentAlignment = Alignment.Center,
        ) {
            Text(text = text)
        }
    }
}

Usage sample:

@Composable
private fun Content() {

val gradient =
    Brush.horizontalGradient(listOf(Color(0xFF28D8A3), Color(0xFF00BEB2)))

    Column {
        GradientButton(
            text = "Gradient Button - Max Width",
            gradient = gradient,
            modifier = Modifier
                .fillMaxWidth()
                .padding(horizontal = 16.dp, vertical = 8.dp)
        )
        GradientButton(
            text = "Gradient Button - Wrap Width",
            gradient = gradient,
            modifier = Modifier
                .wrapContentWidth()
                .padding(horizontal = 16.dp, vertical = 8.dp)
        )
    }
}

Result sample:

Actually, you don't need the button... You can achieve this result using a simple Text...

Text(
    text = "Click Me",
    style = TextStyle(color = Color.White),
    modifier = Modifier
        .clickable(onClick = {})
        .background(
            Brush.verticalGradient(
                colors = listOf(
                    Color.Blue,
                    Color.Green
                )
            ),
            shape = RoundedCornerShape(4.dp)
        )
        .padding(horizontal = 16.dp, vertical = 8.dp),
)

The most flexible way would be to use a TextButton with Modifier.drawBehind().

TextButton doesn't draw any background of its own, but behaves like a button.

Modifier.drawBehind() gives you full control over what you want to draw: gradients, geometrical shapes, etc.

TextButton(modifier = Modifier.drawBehind { }) {
  Text("Help")
}

Jetpack Compose is so flexible about creating Button or any other components, basically Button is Row inside a Surface with content padding as

private val ButtonHorizontalPadding = 16.dp
private val ButtonVerticalPadding = 8.dp

So it's possible to set padding to 0 and set padding after setting gradient background for Text such as in the snippet below.

Button(contentPadding = PaddingValues(0.dp), onClick = {}) {
    Text(
        text = "Vertical Gradient",
        modifier = Modifier
            .preferredHeight(ButtonDefaults.MinHeight)
            .align(Alignment.CenterVertically)
            .background(brush = verticalGradientBrush)
            .padding(8.dp)
    )
}

Implementation based on the default Button composable with all its parameters and customisation options.

@OptIn(ExperimentalMaterialApi::class)
@Composable
fun GradientButton(
    onClick: () -> Unit,
    gradient: Brush,
    modifier: Modifier = Modifier,
    enabled: Boolean = true,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
    elevation: ButtonElevation? = ButtonDefaults.elevation(),
    shape: Shape = MaterialTheme.shapes.small,
    border: BorderStroke? = null,
    contentColor: Color = MaterialTheme.colors.onSurface,
    disabledContentColor: Color = MaterialTheme.colors.onSurface.copy(alpha = ContentAlpha.disabled),
    disabledBackgroundColor: Color = MaterialTheme.colors.onSurface.copy(alpha = 0.12f)
        .compositeOver(MaterialTheme.colors.surface),
    contentPadding: PaddingValues = ButtonDefaults.ContentPadding,
    content: @Composable RowScope.() -> Unit
) {
    val actualElevation = elevation?.elevation(enabled, interactionSource)?.value ?: 0.dp
    val actualContentColor = if (enabled) contentColor else disabledContentColor
    val background = if (enabled) {
        Modifier.background(brush = gradient)
    } else {
        Modifier.background(color = disabledBackgroundColor)
    }
    
    Surface(
        modifier = modifier
            .shadow(actualElevation, shape, true)
            .then(background),
        shape = shape,
        color = Color.Transparent,
        contentColor = actualContentColor.copy(alpha = 1f),
        border = border,
        elevation = 0.dp,
        onClick = onClick,
        enabled = enabled,
        role = Role.Button,
        interactionSource = interactionSource,
        indication = rememberRipple()
    ) {
        CompositionLocalProvider(LocalContentAlpha provides actualContentColor.alpha) {
            ProvideTextStyle(
                value = MaterialTheme.typography.button
            ) {
                Row(
                    Modifier
                        .defaultMinSize(
                            minWidth = ButtonDefaults.MinWidth,
                            minHeight = ButtonDefaults.MinHeight
                        )
                        .padding(contentPadding),
                    horizontalArrangement = Arrangement.Center,
                    verticalAlignment = Alignment.CenterVertically,
                    content = content
                )
            }
        }
    }
}

Example screenshot with and without Modifier.fillMaxWidth

GradientButton file be like:

@Composable
fun GradientButton(
    text: String,
    textColor: Color,
    gradient: Brush,
    onClick: () -> Unit
) {
    Button(
        colors = ButtonDefaults.buttonColors(
            backgroundColor = Color.Transparent
        ),
        contentPadding = PaddingValues(),
        onClick = { onClick() })
    {
        Box(
            modifier = Modifier
                .background(gradient)
                .padding(horizontal = 16.dp, vertical = 8.dp),
            contentAlignment = Alignment.Center
        ) {
            Text(text = text, color = textColor)
        }
    }
}

MainActivity.kt file

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            // Row is used for align the buttons in center of screen
            Row(
                modifier = Modifier.fillMaxSize(),
                horizontalArrangement = Arrangement.Center,
                verticalAlignment = Alignment.CenterVertically
            ) {
                // this is the first button
                GradientButton(
                    text = "Button1", textColor = Color.Black, gradient = Brush.horizontalGradient(
                        colors = listOf(
                            c1,
                            c2,
                            c1
                        )
                    )
                ) {}

                // Spacer is used to give the space between two buttons
                Spacer(modifier = Modifier.width(10.dp))

                // This is second button
                GradientButton(
                    text = "Button2", textColor = Color.Black, gradient = Brush.horizontalGradient(
                        colors = listOf(
                            c3,
                            c4,
                            c3
                        )
                    )
                ) {}

            }
        }
    }

}

Color.kt file

[val c1 = Color(0xFFE9F190)
val c2 = Color(0xFFF5DB0B)

val c3 = Color(0xFFF79F1E)
val c4 = Color(0xFFFF5722)

Output:

I created a box as a background for clickable element. And then add modifier .background to it, with brush+horizontal gradient, as a parameter.

                  Box(contentAlignment = Alignment.Center,
                    modifier = Modifier
                        .background(
                            brush = Brush.horizontalGradient(
                                listOf(Color.Red, Color.Green, Color.Blue),
                                10.0f,
                                20.0f
                            ), shape = CircleShape
                        )