TextField with hint text in jetpack compose

Question

I want to create textfield with hint text in jetpackcompose. Any example how create textfield using jectpack? Thanks

score 74 · Answer 1 · answered May 26 '21 at 10:55

74

compose_version = '1.0.0-beta07'

Use parameter placeholder to show hint

TextField(value = "", onValueChange = {}, placeholder = { Text("Enter Email") })

Use parameter label to show floating label

TextField(value = "", onValueChange = {}, label = { Text("Enter Email") })

answered May 26 '21 at 10:55

Syed Hussain Mehdi

1,168
1
11
15

1

They can't be used together however. They should be able to work together, but can't. you can't set a hint that then becomes the label when the field is populated. – Brill Pappin Sep 08 '22 at 13:11
Are they supposed to be mutually exclusive? I don't see that in the documentation. – Brill Pappin Sep 08 '22 at 13:26

Gabriele Mariotti · Answer 2 · 2022-09-08T10:14:51.147

53

You can use

the label parameter in the TextField composable to display a floating label
the placeholder parameter to display a placeholder when the text field is in focus and the input text is empty.

You can also use them together.

Something like:

var text by remember { mutableStateOf("text") }

OutlinedTextField(
        value = text, 
        onValueChange = {
             text = it
        },
        label = { 
           Text("Label") 
        }
)

or

TextField(
    value = text, 
    onValueChange = {
         text = it
    },
    label = { 
         Text("Label") 
    },
    placeholder = { 
         Text("Placeholder") 
    }
)

edited Sep 08 '22 at 10:14

answered Jun 30 '20 at 15:53

Gabriele Mariotti

320,139
94
887
841

10

Note: you need these 2 imports: `import androidx.compose.runtime.getValue` and `import androidx.compose.runtime.setValue`. The current canary of Android Studio doesn't automatically add them. – Cristan Mar 04 '21 at 19:59
Or you can just add `import androidx.compose.runtime.*` like this. – Isaac Lee Aug 18 '21 at 23:51

score 12 · Accepted Answer · edited Oct 09 '20 at 19:11

You can create hintTextField in jetpackCompose like below code:

@Composable
fun HintEditText(hintText: @Composable() () -> Unit) {
    val state = state { "" } // The unary plus is no longer needed. +state{""}
    val inputField = @Composable {
        TextField(
            value = state.value,
            onValueChange = { state.value = it }
        )
    }
    if (state.value.isNotEmpty()) {
        inputField()
    } else {
        Layout(inputField, hintText) { measurable, constraints ->
        val inputfieldPlacable = measurable[inputField].first().measure(constraints)
        val hintTextPlacable = measurable[hintText].first().measure(constraints)
        layout(inputfieldPlacable.width, inputfieldPlacable.height) {
                inputfieldPlacable.place(0.ipx, 0.ipx)
                hintTextPlacable.place(0.ipx, 0.ipx)
        } }
    }
}

Call @Compose function like below:

HintEditText @Composable {
                                Text(
                                    text = "Enter Email",
                                    style = TextStyle(
                                        color = Color.White,
                                        fontSize = 18.sp
                                    )
                                )
                            }

Habib Kazemi · Answer 4 · 2020-04-03T17:25:39.547

Jetpack compose version: dev08

The benefit of compose is that we can easily create our widgets by composing current composable functions.

We can just create a function with all parameters of the current TextField and add a hint: String parameter.

@Composable
fun TextFieldWithHint(
        value: String,
        modifier: Modifier = Modifier.None,
        hint: String,
        onValueChange: (String) -> Unit,
        textStyle: TextStyle = currentTextStyle(),
        keyboardType: KeyboardType = KeyboardType.Text,
        imeAction: ImeAction = ImeAction.Unspecified,
        onFocus: () -> Unit = {},
        onBlur: () -> Unit = {},
        focusIdentifier: String? = null,
        onImeActionPerformed: (ImeAction) -> Unit = {},
        visualTransformation: VisualTransformation? = null,
        onTextLayout: (TextLayoutResult) -> Unit = {}
) {
    Stack(Modifier.weight(1f)) {
        TextField(value = value,
                modifier = modifier,
                onValueChange = onValueChange,
                textStyle = textStyle,
                keyboardType = keyboardType,
                imeAction = imeAction,
                onFocus = onFocus,
                onBlur = onBlur,
                focusIdentifier = focusIdentifier,
                onImeActionPerformed = onImeActionPerformed,
                visualTransformation = visualTransformation,
                onTextLayout = onTextLayout)
        if (value.isEmpty()) Text(hint)
    }
}

We can use it like this:

@Model
object model { var text: String = "" }
TextFieldWithHint(value = model.text, onValueChange = { data -> model.text = data },
                    hint= "Type book name or author")

The pitfall of this approach is we are passing the hint as a string so if we want to style the hint we should add extra parameters to the TextFieldWithHint (e.g hintStyle, hintModifier, hintSoftWrap, ...)

The better approach is to accept a composable lambda instead of string:

@Composable
fun TextFieldWithHint(
        value: String,
        modifier: Modifier = Modifier.None,
        hint: @Composable() () -> Unit,
        onValueChange: (String) -> Unit,
        textStyle: TextStyle = currentTextStyle(),
        keyboardType: KeyboardType = KeyboardType.Text,
        imeAction: ImeAction = ImeAction.Unspecified,
        onFocus: () -> Unit = {},
        onBlur: () -> Unit = {},
        focusIdentifier: String? = null,
        onImeActionPerformed: (ImeAction) -> Unit = {},
        visualTransformation: VisualTransformation? = null,
        onTextLayout: (TextLayoutResult) -> Unit = {}
) {
    Stack(Modifier.weight(1f)) {
        TextField(value = value,
                modifier = modifier,
                onValueChange = onValueChange,
                textStyle = textStyle,
                keyboardType = keyboardType,
                imeAction = imeAction,
                onFocus = onFocus,
                onBlur = onBlur,
                focusIdentifier = focusIdentifier,
                onImeActionPerformed = onImeActionPerformed,
                visualTransformation = visualTransformation,
                onTextLayout = onTextLayout)
        if (value.isEmpty()) hint()
    }
}

We can use it like this:

@Model
object model { var text: String = "" }

TextFieldWithHint(value = model.text, onValueChange = { data -> model.text = data },
            hint= { Text("Type book name or author", style = TextStyle(color = Color(0xFFC7C7C7))) })

score 1 · Answer 5 · answered Aug 02 '21 at 10:06

    var textState by remember { mutableStateOf(TextFieldValue()) }
    var errorState by remember { mutableStateOf(false) }
    var errorMessage by remember { mutableStateOf("") }


        TextField(
            value = textState,
            onValueChange = {
                textState = it
                when {
                    textState.text.isEmpty() -> {
                        errorState = true
                        errorMessage = "Please Enter Site Code"
                    }
                    else -> {
                        errorState = false
                        errorMessage = ""
                    }
                }
            },
            isError = errorState,
            label = {
                Text(
                    text = if (errorState) errorMessage
                    else "You Hint"
                )
            },
            modifier = Modifier
                .padding(top = 20.dp, start = 30.dp, end = 30.dp)
                .fillMaxWidth())

Parmesh · Answer 6 · 2022-07-02T05:35:57.353

1

If you want to create a text field with hint text and custom color here is the code for that.

@Composable
fun PhoneOrEmail() {
     var text by remember { mutableStateOf("") }

     TextField(
         value = text,
         onValueChange = { text = it },
         label = { Text("Phone/email", style = TextStyle(color = 
         Color.Red)) }
    )//End of TextField
 }//End of Function

edited Jul 02 '22 at 05:35

answered Jul 02 '22 at 05:30

Parmesh

480
4
11

score 0 · Answer 7 · answered Jan 29 '20 at 20:03

Here's what works for me (I think it's a bit simpler than what Anas posted since it's using the same component:

@Composable
fun TextBox(
    loginInput: LoginInput,
    hint: String = "enter value",
    color: Color = Color.LightGray,
    height: Dp = 50.dp
) {

    val state = +state { "" }
    state.value = if (loginInput.usernameEntered) loginInput.username else hint

    Surface(color = color) {
        Row {
            Container(modifier = Expanded, height = height) {
                Clip(shape = RoundedCornerShape(15.dp)) {
                    Padding(padding = 15.dp) {
                        TextField(
                            value = state.value,
                            keyboardType = KeyboardType.Text,
                            onFocus = {
                                if (!loginInput.usernameEntered)
                                    state.value = ""
                            },
                            onValueChange = {
                                loginInput.usernameEntered = true
                                loginInput.username = it
                                state.value = loginInput.username
                            }
                        )
                    }
                }
            }
        }

    }
}

score 0 · Answer 8 · answered Jan 28 '21 at 15:05

the label parameter will be displayed as text if text is empty and moves above the textfield (as label) on typing input:

    @Composable
    fun SearchField() {
        val (text, setText) = remember { mutableStateOf(TextFieldValue("")) }
        Box(modifier = Modifier.width(180.dp).padding(2.dp)) {
            TextField(
                modifier = Modifier.fillMaxWidth(),
                value = text,
                onValueChange = { setText(it) },
                label = { Text("quick do:") },
            )
        }
    }

TextField with hint text in jetpack compose

8 Answers8