Android EditText 提示大小

小开

You can reduce the font size on the EditText - that will reduce the size of the hint as well. i.e. android:textSize="16sp"

小开

I also had to do this as my hint didn't fit in the EditText at the standard size. So I did this (in the xml set textSize to mHintTextSize):

MYEditText.addTextChangedListener(new TextWatcher(){


@Override
public void afterTextChanged(Editable arg0) {
// TODO Auto-generated method stub


}


@Override
public void beforeTextChanged(CharSequence arg0, int arg1,
int arg2, int arg3) {
// TODO Auto-generated method stub


}


@Override
public void onTextChanged(CharSequence arg0, int start, int before,
int count) {
if (arg0.length() == 0) {
// No entered text so will show hint
editText.setTextSize(TypedValue.COMPLEX_UNIT_SP, mHintTextSize);
} else {
editText.setTextSize(TypedValue.COMPLEX_UNIT_SP, mRealTextSize);
}
}
});

小开

You can set simple HTML attributes to the hint string itself.

See accepted answer here: Android EditText hint

EDIT: just played with it myself, this worked for me:

view.setHint(Html.fromHtml("<small><small><small>" +
getString(R.string.hint) + "</small></small></small>"));

This is a list of tags accepted by fromHtml: http://commonsware.com/blog/Android/2010/05/26/html-tags-supported-by-textview.html (though didn't work for me)

小开

it is easy to reduce the hint size of the edittext

editText.setHint(Html.fromHtml(
"<font size=\"5\">" + "hinttext1" + "</font>" +
"<small>" + "hinttext2" + "</small>" ));

小开

@marmor 's Approach is the best One. You can alter the number of  --- tags to adjust size.

You can also define the text of Hint directly as I did

view.setHint(Html.fromHtml("" + "This is Hint" + ""));

Hope this will help.

小开

If you want to do it programmatically,

SpannableString span = new SpannableString(strHint);
span.setSpan(new RelativeSizeSpan(0.5f), 0, strHint.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
editText.setHint(span);

小开

@user2982553 's solution works great for me. You could also use AbsoluteSizeSpan, with which you can set the exact font size of the hint. Don't use  tag, 'cause the size attribute is just ignored.

小开

You can do it by setting a size in the string recource.

For example:

<string name="edittext_hint"><font size="15">Hint here!</font></string>

then in your XML just write

android:hint="@string/edittext_hint"

This will resault in a smaller text for the hint but the original size for the input text.

Hopes this helps for future readers

小开

I need to set a larger size for real text than hint.

public static class LargeSizeTextWatcher implements TextWatcher {


private final EditText mEditText;
private final int mOriginalSize;
private final int mLargeSize;


private int mLastLength;


TrackingNumberTextWatcher(EditText editText) {
mEditText = editText;
mOriginalSize = (int) editText.getTextSize();
mLargeSize = editText.getResources().getDimensionPixelSize(R.dimen.text_size_large);


mLastLength = editText.length();
if (mLastLength != 0) {
mEditText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mLargeSize);
}
}


@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}


@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}


@Override
public void afterTextChanged(Editable s) {
int length = s.length();
if (length == 0) {
mEditText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mOriginalSize);
} else if (mLastLength == 0) {
mEditText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mLargeSize);
}
mLastLength = length;
}
}

小开

You can change not only a hint's size but also its font and style. I achieved to solve it using SpannableString and MetricAffectingSpan

1) Create a custom Hint object:

import android.graphics.Typeface;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.style.MetricAffectingSpan;


public class CustomHint extends SpannableString
{
public CustomHint(final CharSequence source, final int style)
{
this(null, source, style, null);
}


public CustomHint(final CharSequence source, final Float size)
{
this(null, source, size);
}


public CustomHint(final CharSequence source, final int style, final Float size)
{
this(null, source, style, size);
}


public CustomHint(final Typeface typeface, final CharSequence source, final int style)
{
this(typeface, source, style, null);
}


public CustomHint(final Typeface typeface, final CharSequence source, final Float size)
{
this(typeface, source, null, size);
}


public CustomHint(final Typeface typeface, final CharSequence source, final Integer style, final Float size)
{
super(source);


MetricAffectingSpan typefaceSpan = new CustomMetricAffectingSpan(typeface, style, size);
setSpan(typefaceSpan, 0, source.length(), Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
}
}

2) Create custom MetricAffectingSpan object:

import android.graphics.Typeface;
import android.text.TextPaint;
import android.text.style.MetricAffectingSpan;


public class CustomMetricAffectingSpan extends MetricAffectingSpan
{
private final Typeface _typeface;
private final Float    _newSize;
private final Integer  _newStyle;


public CustomMetricAffectingSpan(Float size)
{
this(null, null, size);
}


public CustomMetricAffectingSpan(Float size, Integer style)
{
this(null, style, size);
}


public CustomMetricAffectingSpan(Typeface type, Integer style, Float size)
{
this._typeface = type;
this._newStyle = style;
this._newSize = size;
}


@Override
public void updateDrawState(TextPaint ds)
{
applyNewSize(ds);
}


@Override
public void updateMeasureState(TextPaint paint)
{
applyNewSize(paint);
}


private void applyNewSize(TextPaint paint)
{
if (this._newStyle != null)
paint.setTypeface(Typeface.create(this._typeface, this._newStyle));
else
paint.setTypeface(this._typeface);


if (this._newSize != null)
paint.setTextSize(this._newSize);
}
}

3) Use:

Typeface newTypeface = Typeface.createFromAsset(getAssets(), "AguafinaScript-Regular.ttf");
CustomHint customHint = new CustomHint(newTypeface, "Enter some text", Typeface.BOLD_ITALIC, 60f);
//        CustomHint customHint = new CustomHint(newTypeface, "Enter some text", Typeface.BOLD_ITALIC);
//        CustomHint customHint = new CustomHint(newTypeface, "Enter some text", 60f);
//        CustomHint customHint = new CustomHint("Enter some text", Typeface.BOLD_ITALIC, 60f);
//        CustomHint customHint = new CustomHint("Enter some text", Typeface.BOLD_ITALIC);
//        CustomHint customHint = new CustomHint("Enter some text", 60f);


customEditText.setHint(customHint);

小开

Using onFocusChanged() listener for changing hint font size is also an option, as addTextChangeListener() won't trigger when user clicks on text field, and blinking cursor will resize to hint font.

Also, unlike with TextChangeListener, there is no need to set initial hint font size separately.

class EditTextWithHintSize {
init {
val typedArray = context.obtainStyledAttributes(attrs,
R.styleable.EditTextWithHintSize, 0, defStyle)
try {
hintFontSize = typedArray.getDimension(R.styleable.EditTextWithHintSize_hint_font_size, textSize)
fontSize = textSize


if (length() == 0) {
setTextSize(TypedValue.COMPLEX_UNIT_PX, hintFontSize)
}
} catch (e: Exception) {
hintFontSize = textSize
fontSize = textSize
} finally {
typedArray.recycle()
}
}


override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
super.onFocusChanged(focused, direction, previouslyFocusedRect)


if (focused) {
setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize)
} else {
if (length() == 0) {
setTextSize(TypedValue.COMPLEX_UNIT_PX, hintFontSize)
} else {
setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize)
}
}
}
}

小开

define this in your strings.xml in values folder :

<string name="enter_otp"><font size="16">your text</font></string>