Android自定义View——过滤表情等规则的EditText

最新推荐文章于 2021-05-25 17:50:43 发布
原创 最新推荐文章于 2021-05-25 17:50:43 发布 · 置顶 · 475 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#表情符号 #特殊字符 #限制长度 #自定义view #自定义输入框

这篇博客介绍了如何在Android中自定义一个EditText，以过滤表情符号并限制输入字符的类型和数量。作者通过继承EditText并设置自定义属性来实现这一功能，详细讲解了实现思路、关键代码和注意事项。

前言：需求来了，产品小姐姐展现其高超技能的时候到了，接下来就是闪(粉)亮(墨)登场的时候了，a.登录账号只能输入数字;b.限制下位数；c.密码只输入数字字母和标点符号，总不能输入汉字吧；d.还有那个哪里哪里 你就输入汉字和字母就行了，哪有人的名字有数字啊？e.最重要的是不能输入表情符号等等。针对多才多艺的产品小姐姐，我一个彪形大汉(会写代码的文艺青年)肯定会怜香惜玉一一满足。针对这一有规律的需求，决定自定义View重写EditText来实现之。

项目背景

不想说

需求

  1. 限制输入表情符号
  2. 限制输入字数限制
  3. 英文、汉字、数字等可以多个并存限制字数和输入类型

实现思路

自定义View继承EditText，通过自定义属性来设置过滤器Filter控制输入类型和个数的限制。废话不多说直接上代码：

 

自定义属性如下：

<declare-styleable name="HandyEmojiEdittext">
        <!-- 是否限制输入表情符号 默认限制 -->
        <attr name="emojiFilterable" format="boolean|reference" />
        <!-- 是否过滤空格 默认不过滤 -->
        <attr name="filterSpace" format="boolean|reference" />
        <!-- 输入长度 -->
        <attr name="inputLength" format="integer|reference" />
        <!-- 输入类型 -->
        <attr name="inputTypeEnum">
            <flag name="none" value="0x00" /><!--0000 0000-->
            <flag name="en" value="0x01" /><!--0000 0001-->
            <flag name="zh" value="0x02" /><!--0000 0010-->
            <flag name="num" value="0x04" /><!--0000 0100-->
        </attr>
        <!-- 输入的最大整数 -->
        <attr name="maxNum" format="integer|reference" />
    </declare-styleable>

需要注意的是，inputTypeEnum 输入类型限制设置属性值的时候 跟TextView android:gravity="start|end" 使用规则一样，eg:app:inputTypeEnum="en|zh" 所以value只能是2^n

属性inputTypeEnum解释

算了~不解释了 ~

自己看~很简单的~

inputTypeEnum = typedArray.getInt(R.styleable.HandyEmojiEdittext_inputTypeEnum, 0);
 switch (inputTypeEnum) {
            case 0://none
                inputTypeFilter = null;
                break;
            case 1://en
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[a-zA-Z]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 2://zh
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[\u4e00-\u9fa5]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 3://en & zh
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[a-zA-Z|\u4e00-\u9fa5]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 4://num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[0-9]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            if (maxNum != -1 && dest != null && !StringUtils.isEmpty(dest.toString().trim())) {
                                if (Integer.parseInt(dest.toString().trim() + source) <= maxNum) {
                                    return source;
                                } else {
                                    return "";
                                }
                            }
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 5://en & num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[a-zA-Z|0-9]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 6://zh & num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[\u4e00-\u9fa5|0-9]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 7://en & zh & num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[0-9|a-zA-Z|\u4e00-\u9fa5]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            default:
                inputTypeFilter = null;
                break;
        }

解释：en对应的value是1(0000 0001) zh对应的value是2(0000 0010)， 则  en|zh=3(0000 0011)

 

过滤表情符号

敲黑板

if (emojiFilterable) {
            emojiFilter = new InputFilter() {
                Pattern emoji = Pattern.compile(
                        "[\ud83c\udc00-\ud83c\udfff]|[\ud83d\udc00-\ud83d\udfff]|[\u2600-\u27ff]",
                        Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                @Override
                public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                    Matcher emojiMatcher = emoji.matcher(source);
                    if (emojiMatcher.find()) {
                        return "";
                    }
                    return source;
                }
            };
        }

 

注意

由于是通过设置filter来实现输入限制的规则，那么就不能丢弃原有textview的filter,所以setFilters()方法追加filter来处理

 InputFilter[] filters = new InputFilter[size + getFilters().length];

        int i = 0;
        for (InputFilter f : getFilters()) {
            filters[i++] = f;
        }
        if (emojiFilter != null) {
            filters[i++] = emojiFilter;
        }
        if (lengthFilter != null) {
            filters[i++] = lengthFilter;
        }
        if (inputTypeFilter != null) {
            filters[i++] = inputTypeFilter;
        }
        if (spaceFilter != null) {
            filters[i] = spaceFilter;
        }
        setFilters(filters);

 

为了小伙伴的拿来主义，该自定义view的全部代码如下：

/**
 * 描述：
 * <p>
 * 中英文
 * [a-zA-Z|\u4e00-\u9fa5]
 * 英文
 * [a-zA-Z]
 *
 * @author coo_fee.
 * @Time 2019/7/9.
 */
@SuppressLint("AppCompatCustomView")
public class HandyEmojiEdittext extends EditText {

    /**
     * 是否过滤表情
     * true 默认过滤
     */
    boolean emojiFilterable = true;

    /**
     * 是否过滤空格
     * false 默认不过滤
     */
    boolean mFilterSpace = false;
    /**
     * 输入长度限制
     * <=0 表示没有限制
     */
    int inputLength = 0;
    /**
     * 输入类型
     * 0 none 没有限制
     * 1 en 限制为英文
     * 2 zh 限制为中文
     * 3 en|zh 中文和英文
     */
    int inputTypeEnum = 0;

    /**
     * 输入的最大整数
     * -1 表示无限制
     */
    int maxNum = -1;

    public HandyEmojiEdittext(Context context) {
        super(context);
        init(context, null);
    }

    public HandyEmojiEdittext(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs);
    }

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

    private void init(Context context, AttributeSet attrs) {
        if (attrs != null) {
            TypedArray typedArray = getContext().obtainStyledAttributes(attrs, R.styleable.HandyEmojiEdittext);
            emojiFilterable = typedArray.getBoolean(R.styleable.HandyEmojiEdittext_emojiFilterable, true);
            inputLength = typedArray.getInt(R.styleable.HandyEmojiEdittext_inputLength, 0);
            inputTypeEnum = typedArray.getInt(R.styleable.HandyEmojiEdittext_inputTypeEnum, 0);
            maxNum = typedArray.getInteger(R.styleable.HandyEmojiEdittext_maxNum, -1);
            mFilterSpace = typedArray.getBoolean(R.styleable.HandyEmojiEdittext_filterSpace, false);
        }
        InputFilter emojiFilter = null;
        InputFilter lengthFilter = null;
        InputFilter inputTypeFilter = null;
        InputFilter spaceFilter = null;
        if (emojiFilterable) {
            emojiFilter = new InputFilter() {
                Pattern emoji = Pattern.compile(
                        "[\ud83c\udc00-\ud83c\udfff]|[\ud83d\udc00-\ud83d\udfff]|[\u2600-\u27ff]",
                        Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                @Override
                public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                    Matcher emojiMatcher = emoji.matcher(source);
                    if (emojiMatcher.find()) {
                        return "";
                    }
                    return source;
                }
            };
        }

        if (mFilterSpace) {
            spaceFilter = new InputFilter() {
                Pattern space = Pattern.compile(
                        " ",
                        Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                @Override
                public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                    Matcher spaceMatcher = space.matcher(source);
                    if (spaceMatcher.find()) {
                        return "";
                    }
                    return source;
                }
            };
        }

        if (inputLength > 0) {
            lengthFilter = new InputFilter.LengthFilter(inputLength);
        }
        switch (inputTypeEnum) {
            case 0://none
                inputTypeFilter = null;
                break;
            case 1://en
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[a-zA-Z]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 2://zh
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[\u4e00-\u9fa5]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 3://en & zh
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[a-zA-Z|\u4e00-\u9fa5]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 4://num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[0-9]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            if (maxNum != -1 && dest != null && !StringUtils.isEmpty(dest.toString().trim())) {
                                if (Integer.parseInt(dest.toString().trim() + source) <= maxNum) {
                                    return source;
                                } else {
                                    return "";
                                }
                            }
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 5://en & num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[a-zA-Z|0-9]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 6://zh & num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[\u4e00-\u9fa5|0-9]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            case 7://en & zh & num
                inputTypeFilter = new InputFilter() {
                    Pattern inputTypePattern = Pattern.compile(
                            "[0-9|a-zA-Z|\u4e00-\u9fa5]",
                            Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        Matcher inputTypeMather = inputTypePattern.matcher(source);
                        if (inputTypeMather.find()) {
                            return source;
                        }
                        return "";
                    }
                };
                break;
            default:
                inputTypeFilter = null;
                break;
        }
        int size = 0;
        if (emojiFilter != null) {
            ++size;
        }
        if (lengthFilter != null) {
            ++size;
        }
        if (inputTypeFilter != null) {
            ++size;
        }
        if (spaceFilter != null) {
            ++size;
        }
        InputFilter[] filters = new InputFilter[size + getFilters().length];

        int i = 0;
        for (InputFilter f : getFilters()) {
            filters[i++] = f;
        }
        if (emojiFilter != null) {
            filters[i++] = emojiFilter;
        }
        if (lengthFilter != null) {
            filters[i++] = lengthFilter;
        }
        if (inputTypeFilter != null) {
            filters[i++] = inputTypeFilter;
        }
        if (spaceFilter != null) {
            filters[i] = spaceFilter;
        }
        setFilters(filters);
    }
}

StringUtils.isEmpty()如下：

public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0;
    }

 

写在最后的话

无论多么帅气的代码，都抵挡不住测试兄弟们的骚操作，所以在他手贱复制过来粘贴的时候就不显灵了，欢迎小伙伴们留言、点赞、交流。

 

 

Android EditText 禁止emoj表情输入
12-09
Android EditText 禁止emoj表情输入
android EditText禁止输入法表情
04-29
android EditText禁止输入法表情，完美解决表情不能屏蔽的情况，不存在个别表情屏蔽不了的情况，不明白的地方可以参考我的博客。
android 输入框EditText禁止输入Emoji表情符
04-30
android 输入框EditText禁止输入Emoji表情符，博客地址：http://blog.youkuaiyun.com/elsdnwn/article/details/45390771
android过滤表情
LUFANZHENG的专栏
08-09 455
private static boolean isNotEmojiCharacter(char codePoint) { return (codePoint == 0x0) || (codePoint == 0x9) || (codePoint == 0xA) || (codePoint == 0xD) || ((codePoint >= 0x20) && (codePoint
android中EditText过滤表情
Mr_GLY_di的博客
03-01 603
step1：创建TextWatcher内部类（也可以抽出Utils，我这里直接用了） //输入表情前的光标位置 private var cursorPos: Int = 0 //输入表情前EditText中的文本 private var tmp: String? = null //是否重置了EditText的内容 private var resetText:...
Android自定义EditText带两侧加减按钮控件
此外，还需考虑输入合法性校验——用户可能手动输入非数字字符，因此必须对EditText添加TextWatcher监听，实时过滤非法输入或自动纠正。 为进一步增强可定制性，可通过自定义属性（在attrs.xml中声明）允许外部设置...
Android自定义EditText实现删除及手机号格式化功能
自定义View的创建流程、Drawable资源管理、Touch事件分发机制、TextWatcher文本监听、InputFilter输入过滤、Spannable字符串处理、Canvas绘图基础、StateListDrawable状态管理以及XML属性自定义等。掌握这些知识不仅...
基于EditText的Android自定义智能键盘组件开发库
综上所述，该资源提供了一套完整的、生产级别的Android自定义软键盘解决方案，解决了原生输入法在特定场景下的不足，提升了应用的专业性与交互流畅度。其技术价值体现在模块化设计、多模式支持、智能切换逻辑、安全...
Android自定义ComboBox控件实现
强调“自定义控件”意味着其设计遵循 Android 自定义 View 的规范流程，可能继承自 LinearLayout、RelativeLayout 或直接继承 View 类，并重写 onMeasure()、onDraw()、dispatchTouchEvent() 等方法以实现精确控制。...
安卓Android源码——一个Demo搞定30个控件.zip
10-11
这个压缩包“安卓Android源码——一个Demo搞定30个控件.zip”显然是为了帮助开发者快速熟悉和应用Android SDK中的多种UI元素。它通过一个单一的布局Demo，展示了30种不同的控件，这种方式可以有效地提升学习效率，将...
EditText禁止表情输入
10-26
EmojiEditText可实现禁止表情输入，而且不影响maxLength属性的使用
android edittext过滤表情,Android Edittext过滤表情符号
weixin_42569329的博客
05-25 180
https://scriptedpapers.com/2015/08/25/android-disable-emoji-in-edittext/public static InputFilter EMOJI_FILTER = new InputFilter() {@Overridepublic CharSequence filter(CharSequence source, int start, ...
Android 准确过滤(禁止) Emoji表情
小耳朵图图是我
05-23 1929
## Emoji过滤方法 1. 匹配Emoji表情列表过滤，需要得到Emoji表情列表 2. 区间过滤，可能多过滤也肯少过滤
关于android 过滤表情的总结
baidu_33853807的博客
01-12 764
今天公司后台跟我讲，让我限制不能输入表情，WTF！！！说后台目前不支持存储，会导致数据库报错... 然后我各种网上找资料，发现各种都不能满足搜狗输入法所有表情限制。最后自己总结出这些 public static InputFilter emojiFilter = new InputFilter() { Pattern emoji = Pattern.compile(
android EditText完美解决禁止输入法表情
热门推荐
qq_20967339的博客
04-29 1万+
最近有个需求，需要评论的时候禁止输入法的表情输入。然后在网上各种找，发现有些人啊，也是服了，同样的东西反复写，并且还没解决问题，我就想问问，这个你们自己真的动手运行的了，效果实现了吗，还是说，效果实现了，不想分享出来呢。         作为一个有分享精神的人，我把自己做的分享一下，希望能够帮助有需要的人，同时自己也做做笔记。         在网上搜索的发现有三种方案，我全部拿过来。
android edittext过滤表情,Android中EditText屏蔽第三方输入法表情的方法示例
weixin_39997696的博客
05-25 216
前言众所周知如果用第三方的输入法的表情会给开发带来一定的麻烦，一般地像服务器上传的字符都是普通的字符，但是测试，就是狠狠得拿出搜狗输入法，点几个表情，那么问题就来了，要么是显示异常，要么是直接crash，但是有很少的部分机型，会支持，可能是第三方的ROM对Android 的TextView 做了一定的处理，所以，我们只能干掉该死的表情了。具体的方法如下：首先是在EditTextView 里面加入T...
android edittext过滤表情,EditText过滤emoji表情
weixin_39874366的博客
05-25 336
导语最近在项目中遇到一个输入法自带emoji表情无法上传的问题，想到采用禁止输入emoji的办法(其实后台数据库添加emoji表情符是更好的做法，当然有些输入框确实不需要emoji表情)，搜索了很多文章都没有很完美的过滤方式，最后参考一些文章和emoji编码表实现了一个满足自身需求的。实现/*** 通用表情过滤器*/public class FilterEmojiTextWatcher imple...
android edittext过滤表情,EditText过滤表情符号
weixin_30646295的博客
05-25 424
项目中我们通常可以通过第三方输入法项Android文本框中输入表情符号，但是后台解析时可能会报错，所以通常我们都会屏蔽掉EditText的表情符号输入。下面介绍一下自己为了解决这个问题爬过的坑。第一种解决方案(错误的)：public boolean isEmojiCharacter(char codePoint) {return !((codePoint == 0x0) || (codePoint...
Android EditText禁止输入emoji表情的一种方法
海纳百川Android的博客
03-25 4565
在安卓app开发中，会遇到EditText禁止输入emoji表情的需求，方法很简单，只需要给EditText添加一个InputFilter就行了，如下面代码： public class EmojiInputFilter implements InputFilter { protected Pattern emoji = Pattern.compile("[\ud83c\udc00-\ud83c\udfff]|[\ud83d\udc00-\ud83d\udfff]|[\u2600-\u27
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值