weijunfeng
3/11/2019 - 1:40 PM

android:inputType属性和setInputType()方法参数对应整理

android:inputType属性和setInputType()方法参数对应整理
2016年09月09日 15:57:30 csdn小瓯 阅读数:9712 标签: android  更多
个人分类: Android开发
版权声明:欢迎转载,关注。转载请注明出处。	https://blog.csdn.net/u014158743/article/details/52488010
前言:自己原来EditText.setInputType()方法里的参数都不知道该写什么, 真是醉了。 
转载请注明出处:http://blog.csdn.net/u014158743/article/details/52488010

| 以密码类型(password)为例 
android:inputType属性:

<EditText
        android:inputType="textPassword"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
1
2
3
4
setInputType()参数:

EditText pwd = new EditText(context);
pwd.setInputType(InputType.TYPE_CLASS_TEXT|InputType.TYPE_TEXT_VARIATION_PASSWORD);
1
2
| 注意:通过代码给InputType赋值时,不是设置TYPE_XXX_VARIATION_YYY,而是要设置TYPE_CLASS_XXX | TYPE_XXXX_VARAITION_YYY
Android之设置EditText输入类型(setInputType()方法和android:inputType属性)
2015年11月29日 10:45:53 志见 阅读数:6842
 版权声明:本文为博主原创文章,转载请注明出处。	https://blog.csdn.net/wei_zhi/article/details/50094503
在Android开发过程中,我们经常使用到EditText控件,并且会根据各种需求设置它的输入类型。设置EditText输入类型主要有两种方法,一种是使用EditText的setInputType()方法,另一种是在布局文件中使用android:inputType属性来设置。 
下面将介绍这两种方法:

(1)使用EditText的setInputType()方法设置输入类型:

    EditText editText;

    //输入类型为没有指定明确的类型的特殊内容类型
    editText.setInputType(InputType.TYPE_NULL);

    //输入类型为普通文本
    editText.setInputType(InputType.TYPE_CLASS_TEXT);

    //输入类型为数字文本
    editText.setInputType(InputType.TYPE_CLASS_NUMBER);

    //输入类型为电话号码
    editText.setInputType(InputType.TYPE_CLASS_PHONE);

    //输入类型为日期和时间
    editText.setInputType(InputType.TYPE_CLASS_DATETIME);

    //输入类型为{@link#TYPE_CLASS_DATETIME}的缺省变化值,允许输入日期和时间。
    editText.setInputType(InputType.TYPE_DATETIME_VARIATION_NORMAL);

    //输入类型为{@link#TYPE_CLASS_DATETIME}的缺省变化值,只允许输入一个日期。
    editText.setInputType(InputType.TYPE_DATETIME_VARIATION_DATE);

    //输入类型为{@link#TYPE_CLASS_DATETIME}的缺省变化值,只允许输入一个时间。
    editText.setInputType(InputType.TYPE_DATETIME_VARIATION_TIME);

    //输入类型为决定所给文本整体类的位掩码
    editText.setInputType(InputType.TYPE_MASK_CLASS);

    //输入类型为提供附加标志位选项的位掩码
    editText.setInputType(InputType.TYPE_MASK_FLAGS);

    //输入类型为决定基类内容变化的位掩码
    editText.setInputType(InputType.TYPE_MASK_VARIATION);

    //输入类型为小数数字,允许十进制小数点提供分数值。
    editText.setInputType(InputType.TYPE_NUMBER_FLAG_DECIMAL);
    //输入类型为数字是带符号的,允许在开头带正号或者负号
    editText.setInputType(InputType.TYPE_NUMBER_FLAG_SIGNED);

    //输入类型为{@link#TYPE_CLASS_NUMBER}的缺省变化值:为纯普通数字文本
    editText.setInputType(InputType.TYPE_NUMBER_VARIATION_NORMAL);

    //输入类型为{@link#TYPE_CLASS_NUMBER}的缺省变化值:为数字密码
    editText.setInputType(InputType.TYPE_NUMBER_VARIATION_PASSWORD);

    //输入类型为自动完成文本类型
    editText.setInputType(InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE);

    //输入类型为自动纠正文本类型
    editText.setInputType(InputType.TYPE_TEXT_FLAG_AUTO_CORRECT);

    //输入类型为所有字符大写
    editText.setInputType(InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS);

    //输入类型为每句的第一个字符大写
    editText.setInputType(InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);

    //输入类型为每个单词的第一个字母大写
    editText.setInputType(InputType.TYPE_TEXT_FLAG_CAP_WORDS);

    //输入多行文本
    editText.setInputType(InputType.TYPE_TEXT_FLAG_IME_MULTI_LINE);

    //进行输入时,输入法无提示
    editText.setInputType(InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);

    //输入一个短的,可能是非正式的消息,如即时消息或短信。
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE);

    //输入长内容,可能是正式的消息内容,比如电子邮件的主体
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_LONG_MESSAGE);

    //输入文本以过滤列表等内容
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_FILTER);

    //输入一个电子邮件地址
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS);

    //输入电子邮件主题行
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_EMAIL_SUBJECT);

    //输入一个密码
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

    //输入老式的普通文本
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_NORMAL);

    //输入人名
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_PERSON_NAME);

    //输入邮寄地址
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_POSTAL_ADDRESS);

    //输入语音发音输入文本,如联系人拼音名称字段
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_PHONETIC);

    //输入URI
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_URI);

    //输入对用户可见的密码
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

    //输入网页表单中的文本
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT);

    //输入网页表单中的邮件地址
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS);

    //输入网页表单中的密码
    editText.setInputType(InputType.TYPE_TEXT_VARIATION_WEB_PASSWORD);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
下面是几个简单的例子:

        /**
         * 第一个例子:对用户可见的密码字段
         */
        editText.setInputType(InputType.TYPE_CLASS_TEXT |
                InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

        /**
         * 第二个例子:具有自动大写的多行邮寄地址
         */
        editText.setInputType(InputType.TYPE_CLASS_TEXT |
                InputType.TYPE_TEXT_VARIATION_POSTAL_ADDRESS |
                InputType.TYPE_TEXT_FLAG_MULTI_LINE);

        /**
         * 第三个例子:一个时间字段
         */
        editText.setInputType(InputType.TYPE_CLASS_DATETIME |
                InputType.TYPE_DATETIME_VARIATION_TIME);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
在本文的后续,将会附上Android源码中的InputType.java。

(2)在布局文件中使用android:inputType属性来设置:

    //输入类型为没有指定明确的类型的特殊内容类型
    android:inputType="none"

    //输入类型为普通文本
    android:inputType="text"

     //输入类型为数字文本
     android:inputType="number"

    //输入类型为电话号码
     android:inputType=”phone”

    //输入类型为日期和时间
     android:inputType=”datetime”

     //输入类型为{@link#TYPE_CLASS_DATETIME}的缺省变化值,只允许输入一个日期。
     android:inputType=”date”

     //输入类型为{@link#TYPE_CLASS_DATETIME}的缺省变化值,只允许输入一个时间。
     android:inputType=”time”

    //输入类型为小数数字,允许十进制小数点提供分数值。
     android:inputType="numberDecimal"

    //输入类型为数字是带符号的,允许在开头带正号或者负号
     android:inputType="numberSigned"

    //输入类型为数字密码
     android:inputType="numberPassword"

    //输入类型为自动完成文本类型
     android:inputType="textAutoComplete"

    //输入类型为自动纠正文本类型
     android:inputType="textAutoCorrect"

    //输入类型为所有字符大写
     android:inputType="textCapCharacters"

    //输入类型为每句的第一个字符大写
     android:inputType="textCapSentences"

    //输入类型为每个单词的第一个字母大写
     android:inputType="textCapWords"

    //输入法多行文本
     android:inputType="textImeMultiLine"

    //进行输入时,输入法无提示
     android:inputType="textNoSuggestions"

     //输入一个短的,可能是非正式的消息,如即时消息或短信。
     android:inputType="textShortMessage"

    //输入长内容,可能是正式的消息内容,比如电子邮件的主体
     android:inputType="textLongMessage"

    //输入文本以过滤列表等内容
     android:inputType="textFilter"

    //输入一个电子邮件地址
     android:inputType="textEmailAddress"

    //输入电子邮件主题行
     android:inputType="textEmailSubject"

    //输入一个密码
     android:inputType="textPassword"

    //输入对用户可见的密码
     android:inputType="textVisiblePassword"

    //输入人的姓名
     android:inputType="textPersonName"

    //输入邮寄地址
     android:inputType="textPostalAddress"

    //输入语音发音输入文本,如联系人拼音名称字段
     android:inputType="textPhonetic"

    //输入URI
     android:inputType="textUri"

    //输入网页表单中的文本
     android:inputType="textWebEditText"

    //输入网页表单中的邮件地址
     android:inputType="textWebEmailAddress"

    //输入网页表单中的密码
     android:inputType="textWebPassword"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
最后,附上上Android源码中的InputType.java:

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.text;

import android.text.TextUtils;

/**
 * Bit definitions for an integer defining the basic content type of text
 * held in an {@link Editable} object. Supported classes may be combined
 * with variations and flags to indicate desired behaviors.
 *
 * <h3>Examples</h3>
 *
 * <dl>
 * <dt>A password field with with the password visible to the user:
 * <dd>inputType = TYPE_CLASS_TEXT |
 *     TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
 *
 * <dt>A multi-line postal address with automatic capitalization:
 * <dd>inputType = TYPE_CLASS_TEXT |
 *     TYPE_TEXT_VARIATION_POSTAL_ADDRESS |
 *     TYPE_TEXT_FLAG_MULTI_LINE
 *
 * <dt>A time field:
 * <dd>inputType = TYPE_CLASS_DATETIME |
 *     TYPE_DATETIME_VARIATION_TIME
 * </dl>
 */
public interface InputType {
    /**
     * Mask of bits that determine the overall class
     * of text being given.  Currently supported classes are:
     * {@link #TYPE_CLASS_TEXT}, {@link #TYPE_CLASS_NUMBER},
     * {@link #TYPE_CLASS_PHONE}, {@link #TYPE_CLASS_DATETIME}.
     * <p>IME authors: If the class is not one you
     * understand, assume {@link #TYPE_CLASS_TEXT} with NO variation
     * or flags.<p>
     */
    public static final int TYPE_MASK_CLASS = 0x0000000f;

    /**
     * Mask of bits that determine the variation of
     * the base content class.
     */
    public static final int TYPE_MASK_VARIATION = 0x00000ff0;

    /**
     * Mask of bits that provide addition bit flags
     * of options.
     */
    public static final int TYPE_MASK_FLAGS = 0x00fff000;

    /**
     * Special content type for when no explicit type has been specified.
     * This should be interpreted to mean that the target input connection
     * is not rich, it can not process and show things like candidate text nor
     * retrieve the current text, so the input method will need to run in a
     * limited "generate key events" mode, if it supports it. Note that some
     * input methods may not support it, for example a voice-based input
     * method will likely not be able to generate key events even if this
     * flag is set.
     */
    public static final int TYPE_NULL = 0x00000000;



    /**
     * Class for normal text.  This class supports the following flags (only
     * one of which should be set):
     * {@link #TYPE_TEXT_FLAG_CAP_CHARACTERS},
     * {@link #TYPE_TEXT_FLAG_CAP_WORDS}, and.
     * {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}.  It also supports the
     * following variations:
     * {@link #TYPE_TEXT_VARIATION_NORMAL}, and
     * {@link #TYPE_TEXT_VARIATION_URI}.  If you do not recognize the
     * variation, normal should be assumed.
     */
    public static final int TYPE_CLASS_TEXT = 0x00000001;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: capitalize all characters.  Overrides
     * {@link #TYPE_TEXT_FLAG_CAP_WORDS} and
     * {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}.  This value is explicitly defined
     * to be the same as {@link TextUtils#CAP_MODE_CHARACTERS}. Of course,
     * this only affects languages where there are upper-case and lower-case letters.
     */
    public static final int TYPE_TEXT_FLAG_CAP_CHARACTERS = 0x00001000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of
     * every word.  Overrides {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}.  This
     * value is explicitly defined
     * to be the same as {@link TextUtils#CAP_MODE_WORDS}. Of course,
     * this only affects languages where there are upper-case and lower-case letters.
     */
    public static final int TYPE_TEXT_FLAG_CAP_WORDS = 0x00002000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of
     * each sentence.  This value is explicitly defined
     * to be the same as {@link TextUtils#CAP_MODE_SENTENCES}. For example
     * in English it means to capitalize after a period and a space (note that other
     * languages may have different characters for period, or not use spaces,
     * or use different grammatical rules). Of course,
     * this only affects languages where there are upper-case and lower-case letters.
     */
    public static final int TYPE_TEXT_FLAG_CAP_SENTENCES = 0x00004000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: the user is entering free-form
     * text that should have auto-correction applied to it. Without this flag,
     * the IME will not try to correct typos. You should always set this flag
     * unless you really expect users to type non-words in this field, for
     * example to choose a name for a character in a game.
     * Contrast this with {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE} and
     * {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:
     * {@code TYPE_TEXT_FLAG_AUTO_CORRECT} means that the IME will try to
     * auto-correct typos as the user is typing, but does not define whether
     * the IME offers an interface to show suggestions.
     */
    public static final int TYPE_TEXT_FLAG_AUTO_CORRECT = 0x00008000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: the text editor (which means
     * the application) is performing auto-completion of the text being entered
     * based on its own semantics, which it will present to the user as they type.
     * This generally means that the input method should not be showing
     * candidates itself, but can expect the editor to supply its own
     * completions/candidates from
     * {@link android.view.inputmethod.InputMethodSession#displayCompletions
     * InputMethodSession.displayCompletions()} as a result of the editor calling
     * {@link android.view.inputmethod.InputMethodManager#displayCompletions
     * InputMethodManager.displayCompletions()}.
     * Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and
     * {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:
     * {@code TYPE_TEXT_FLAG_AUTO_COMPLETE} means the editor should show an
     * interface for displaying suggestions, but instead of supplying its own
     * it will rely on the Editor to pass completions/corrections.
     */
    public static final int TYPE_TEXT_FLAG_AUTO_COMPLETE = 0x00010000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: multiple lines of text can be
     * entered into the field.  If this flag is not set, the text field 
     * will be constrained to a single line. The IME may also choose not to
     * display an enter key when this flag is not set, as there should be no
     * need to create new lines.
     */
    public static final int TYPE_TEXT_FLAG_MULTI_LINE = 0x00020000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: the regular text view associated
     * with this should not be multi-line, but when a fullscreen input method
     * is providing text it should use multiple lines if it can.
     */
    public static final int TYPE_TEXT_FLAG_IME_MULTI_LINE = 0x00040000;

    /**
     * Flag for {@link #TYPE_CLASS_TEXT}: the input method does not need to
     * display any dictionary-based candidates. This is useful for text views that
     * do not contain words from the language and do not benefit from any
     * dictionary-based completions or corrections. It overrides the
     * {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} value when set.
     * Please avoid using this unless you are certain this is what you want.
     * Many input methods need suggestions to work well, for example the ones
     * based on gesture typing. Consider clearing
     * {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} instead if you just do not
     * want the IME to correct typos.
     * Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and
     * {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE}:
     * {@code TYPE_TEXT_FLAG_NO_SUGGESTIONS} means the IME should never
     * show an interface to display suggestions. Most IMEs will also take this to
     * mean they should not try to auto-correct what the user is typing.
     */
    public static final int TYPE_TEXT_FLAG_NO_SUGGESTIONS = 0x00080000;



    /**
     * Default variation of {@link #TYPE_CLASS_TEXT}: plain old normal text.
     */
    public static final int TYPE_TEXT_VARIATION_NORMAL = 0x00000000;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering a URI.
     */
    public static final int TYPE_TEXT_VARIATION_URI = 0x00000010;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering an e-mail address.
     */
    public static final int TYPE_TEXT_VARIATION_EMAIL_ADDRESS = 0x00000020;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering the subject line of
     * an e-mail.
     */
    public static final int TYPE_TEXT_VARIATION_EMAIL_SUBJECT = 0x00000030;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering a short, possibly informal
     * message such as an instant message or a text message.
     */
    public static final int TYPE_TEXT_VARIATION_SHORT_MESSAGE = 0x00000040;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering the content of a long, possibly 
     * formal message such as the body of an e-mail.
     */
    public static final int TYPE_TEXT_VARIATION_LONG_MESSAGE = 0x00000050;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering the name of a person.
     */
    public static final int TYPE_TEXT_VARIATION_PERSON_NAME = 0x00000060;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering a postal mailing address.
     */
    public static final int TYPE_TEXT_VARIATION_POSTAL_ADDRESS = 0x00000070;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering a password.
     */
    public static final int TYPE_TEXT_VARIATION_PASSWORD = 0x00000080;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering a password, which should
     * be visible to the user.
     */
    public static final int TYPE_TEXT_VARIATION_VISIBLE_PASSWORD = 0x00000090;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering text inside of a web form.
     */
    public static final int TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x000000a0;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering text to filter contents
     * of a list etc.
     */
    public static final int TYPE_TEXT_VARIATION_FILTER = 0x000000b0;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering text for phonetic
     * pronunciation, such as a phonetic name field in contacts. This is mostly
     * useful for languages where one spelling may have several phonetic
     * readings, like Japanese.
     */
    public static final int TYPE_TEXT_VARIATION_PHONETIC = 0x000000c0;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering e-mail address inside
     * of a web form.  This was added in
     * {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An IME must target
     * this API version or later to see this input type; if it doesn't, a request
     * for this type will be seen as {@link #TYPE_TEXT_VARIATION_EMAIL_ADDRESS}
     * when passed through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
     * EditorInfo.makeCompatible(int)}.
     */
    public static final int TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS = 0x000000d0;

    /**
     * Variation of {@link #TYPE_CLASS_TEXT}: entering password inside
     * of a web form.  This was added in
     * {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An IME must target
     * this API version or later to see this input type; if it doesn't, a request
     * for this type will be seen as {@link #TYPE_TEXT_VARIATION_PASSWORD}
     * when passed through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
     * EditorInfo.makeCompatible(int)}.
     */
    public static final int TYPE_TEXT_VARIATION_WEB_PASSWORD = 0x000000e0;


    /**
     * Class for numeric text.  This class supports the following flags:
     * {@link #TYPE_NUMBER_FLAG_SIGNED} and
     * {@link #TYPE_NUMBER_FLAG_DECIMAL}.  It also supports the following
     * variations: {@link #TYPE_NUMBER_VARIATION_NORMAL} and
     * {@link #TYPE_NUMBER_VARIATION_PASSWORD}.
     * <p>IME authors: If you do not recognize
     * the variation, normal should be assumed.</p>
     */
    public static final int TYPE_CLASS_NUMBER = 0x00000002;

    /**
     * Flag of {@link #TYPE_CLASS_NUMBER}: the number is signed, allowing
     * a positive or negative sign at the start.
     */
    public static final int TYPE_NUMBER_FLAG_SIGNED = 0x00001000;

    /**
     * Flag of {@link #TYPE_CLASS_NUMBER}: the number is decimal, allowing
     * a decimal point to provide fractional values.
     */
    public static final int TYPE_NUMBER_FLAG_DECIMAL = 0x00002000;


    /**
     * Default variation of {@link #TYPE_CLASS_NUMBER}: plain normal
     * numeric text.  This was added in
     * {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An IME must target
     * this API version or later to see this input type; if it doesn't, a request
     * for this type will be dropped when passed through
     * {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
     * EditorInfo.makeCompatible(int)}.
     */
    public static final int TYPE_NUMBER_VARIATION_NORMAL = 0x00000000;

    /**
     * Variation of {@link #TYPE_CLASS_NUMBER}: entering a numeric password.
     * This was added in {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An
     * IME must target this API version or later to see this input type; if it
     * doesn't, a request for this type will be dropped when passed
     * through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
     * EditorInfo.makeCompatible(int)}.
     */
    public static final int TYPE_NUMBER_VARIATION_PASSWORD = 0x00000010;


    /**
     * Class for a phone number.  This class currently supports no variations
     * or flags.
     */
    public static final int TYPE_CLASS_PHONE = 0x00000003;



    /**
     * Class for dates and times.  It supports the
     * following variations:
     * {@link #TYPE_DATETIME_VARIATION_NORMAL}
     * {@link #TYPE_DATETIME_VARIATION_DATE}, and
     * {@link #TYPE_DATETIME_VARIATION_TIME}.
     */
    public static final int TYPE_CLASS_DATETIME = 0x00000004;

    /**
     * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
     * both a date and time.
     */
    public static final int TYPE_DATETIME_VARIATION_NORMAL = 0x00000000;

    /**
     * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
     * only a date.
     */
    public static final int TYPE_DATETIME_VARIATION_DATE = 0x00000010;

    /**
     * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
     * only a time.
     */
    public static final int TYPE_DATETIME_VARIATION_TIME = 0x00000020;
}
Android 处理EditText光标显示在hint文字之前的问题
96  naturs 
 0.1 2018.02.06 19:44 字数 476 阅读 1267评论 5喜欢 1
最近在项目中有这样一个极其简单需求,需要将输入框内容向右靠齐。为达到这样的效果,修改EditText布局如下:

<EditText
    android:id="@+id/name"
    android:layout_width="match_parent"
    android:layout_height="48dp"
    android:layout_gravity="center_vertical|right"
    android:hint="请输入姓名" />
在一般手机上显示没有任何问题,但在部分手机上显示时光标会显示在hintText之前,如图所示(我用的genymotion 6.0版本的模拟器):

QQ20180206-190500@2x.png
但输入文字内容后又会变成:

QQ20180206-192001@2x.png
显然在未输入内容时,光标的位置是不对的,找了一番并没有找到合适的办法解决该问题。

后来在这里找到一种解决方案:解决EditText文字右对齐时光标出现在hint文字的左边的问题。

主要思想是:既然EditText显示了hint的情况下光标不对,那么我就不显示hint,这样光标就没问题了,然后用一个TextView覆盖在EditText之上,用该TextView来显示hint,最后监听EditText的内容变化,有内容时隐藏TextView。

思路很简单,也很有效。

但是毕竟增加了一个TextView,而且我的项目中大部分EditText都是靠右对齐,改动较大,所以我在该思想的基础上,自定义封装了一个EditText。

主要思想是:不设置EditText的hint,而改由自己绘制。

代码如下(也可以参考 https://gist.github.com/naturs/60935654e016e78cf87ba503dc2b1fc6):

public class FixedCursorEditText extends AppCompatEditText {

    private CharSequence mHint;

    private Paint mHintPaint;
    private int mCurHintTextColor;

    public FixedCursorEditText(Context context) {
        this(context, null);
    }

    public FixedCursorEditText(Context context, AttributeSet attrs) {
        this(context, attrs, android.support.v7.appcompat.R.attr.editTextStyle);
    }

    public FixedCursorEditText(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context, attrs, defStyleAttr);
    }

    private void init(Context context, AttributeSet attrs, int defStyleAttr) {
        mHint = getHint();
        setHint("");
        mHintPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
        mHintPaint.setTextSize(getTextSize());
        mHintPaint.setTextAlign(Paint.Align.RIGHT);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (TextUtils.isEmpty(mHint) || !TextUtils.isEmpty(getText())) {
            return;
        }
        canvas.save();
        ColorStateList hintTextColors = getHintTextColors();
        if (hintTextColors != null) {
            int color = hintTextColors.getColorForState(getDrawableState(), 0);
            if (color != mCurHintTextColor) {
                mCurHintTextColor = color;
                mHintPaint.setColor(color);
            }
        }

        Paint.FontMetricsInt fontMetrics = mHintPaint.getFontMetricsInt();
        int baseline = (getHeight() - fontMetrics.bottom + fontMetrics.top) / 2 - fontMetrics.top;
        canvas.drawText(mHint, 0, mHint.length(),
                getWidth() - getPaddingRight() + getScrollX(),
                baseline, mHintPaint);
        canvas.restore();
    }
}
首先在初始化时拿到设置的hint保存起来,然后清空EditText本身的hint,最后在onDraw()方法中绘制自己的hint。

该代码仅适用于一些简单的情况,如果你有更复杂的逻辑,完全可以扩展它,这里主要是提供一个思路。

最终,光标能正确显示: