Android 单击文本时，键盘未显示

我试图在我的项目中使用有用的库，但在使用该库并单击

EditText

键盘后，没有显示，这个简单的类作为库部署

EditText

public class AlachiqMakeLink extends EditText {

    private static final String TAG = AlachiqMakeLink.class.getSimpleName();
    private static final String DEFAULT_TEXT_COLOR = "FFFFFF";

    private String mParkedText = "";
    private boolean mIsBoldParkedText = true;
    private String mParkedTextColor = DEFAULT_TEXT_COLOR;
    private String mParkedHintColor = DEFAULT_TEXT_COLOR;

    private String mText = null;
    private enum TypingState {
        Start, Typed
    }
    private TypingState mTypingState = TypingState.Start;

    public AlachiqMakeLink(Context context) {
        super(context);
        init();
    }

    public AlachiqMakeLink(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public AlachiqMakeLink(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.AlachiqMakeLink, defStyleAttr, 0);

        mParkedText = a.getString(R.styleable.AlachiqMakeLink_parkedText);
        if (mParkedText == null) {
            mParkedText = "";
        }

        String hint = a.getString(R.styleable.AlachiqMakeLink_parkedHint);

        mParkedTextColor = a.getString(R.styleable.AlachiqMakeLink_parkedTextColor);
        if (mParkedTextColor == null) {
            mParkedTextColor = AlachiqMakeLink.DEFAULT_TEXT_COLOR;
        }

        mParkedHintColor = a.getString(R.styleable.AlachiqMakeLink_parkedHintColor);
        if (mParkedHintColor == null) {
            mParkedHintColor = AlachiqMakeLink.DEFAULT_TEXT_COLOR;
        }

        mIsBoldParkedText = a.getBoolean(R.styleable.AlachiqMakeLink_parkedTextBold, true);

        init();

        if (hint != null) {
            setPlaceholderText(hint);
        }

        a.recycle();
    }

    private void init() {
        mText = "";
        observeText();

        mTypingState = TypingState.Start;
        addTextChangedListener(new ParkedTextViewWatcher(this));
    }

    public String getParkedText() {
        return mParkedText;
    }

    private int getBeginningPositionOfParkedText() {
        int position = mText.length() - mParkedText.length();
        if (position < 0) {
            return 0;
        }
        return position;
    }

    private void goToBeginningOfParkedText() {
        setSelection(getBeginningPositionOfParkedText());
    }

    private String getTypedText() {
        if (mText.endsWith(mParkedText)) {
            return mText.substring(0, getBeginningPositionOfParkedText());
        }
        return mText;
    }

    private void setTypedText(String typedText) {
        mText = typedText;
        observeText();

        textChanged();
    }

    private void setEmptyText() {
        setTypedText("");
    }

    public void setPlaceholderText(String placeholderText) {
        Spanned hint = null;
        String parkedTextColor = reformatColor(mParkedTextColor);
        String parkedHintColor = reformatColor(mParkedHintColor);
        if (mIsBoldParkedText) {
            hint = Html.fromHtml(String.format("<font color=\"#%s\">%s</font><font color=\"#%s\"><b>%s</b></font>", parkedHintColor, placeholderText, parkedTextColor, mParkedText));
        } else {
            hint = Html.fromHtml(String.format("<font color=\"#%s\">%s</font><font color=\"#%s\">%s</font>", parkedHintColor, placeholderText, parkedTextColor, mParkedText));
        }
        super.setHint(hint);
    }

    // Call when TypedText is changed
    private String observeText() {
        return mText = getTypedText() + mParkedText;
    }

    private String reformatColor(String color) {
        if (color.startsWith("#")) {
            color = color.substring(1);
        }

        if (color.length() > 6) {
            return color.substring(2);
        }
        return color;
    }

    private Spanned getHtmlText() {
        String parkedTextColor = reformatColor(mParkedTextColor);
        if (mIsBoldParkedText) {
            return Html.fromHtml(String.format("<font color=\"#%s\">%s</font><font color=\"#%s\"><b>%s</b></font>", parkedTextColor, getTypedText(), parkedTextColor, mParkedText));
        }
        return Html.fromHtml(String.format("<font color=\"#%s\">%s</font>", parkedTextColor, getTypedText() + mParkedText));
    }

    private void textChanged() {
        switch (mTypingState) {
            case Start:
                if (mText.length() <= 0) {
                    return;
                }
                setText(getHtmlText(), BufferType.SPANNABLE);
                goToBeginningOfParkedText();

                mTypingState = TypingState.Typed;

            case Typed:
                if (mText.equals(mParkedText)) {
                    mTypingState = TypingState.Start;
                    setText(getHtmlText(), BufferType.SPANNABLE);
                    return;
                }

                setText(getHtmlText(), BufferType.SPANNABLE);

                goToBeginningOfParkedText();

            default:
                break;
        }
    }

    private static class ParkedTextViewWatcher implements TextWatcher {

        private AlachiqMakeLink mAlachiqMakeLink;
        private boolean         mIsDeleteText;

        public ParkedTextViewWatcher(AlachiqMakeLink alachiqMakeLink) {
            this.mAlachiqMakeLink = alachiqMakeLink;
        }

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

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            if (before > 0) {
                mIsDeleteText = true;
            } else {
                mIsDeleteText = false;
            }
        }

        @Override
        public void afterTextChanged(Editable s) {
            mAlachiqMakeLink.removeTextChangedListener(this);

            String text = s.toString();
            if (mIsDeleteText) {

                if (text.length() < mAlachiqMakeLink.getParkedText().length()) {
                    mAlachiqMakeLink.setEmptyText();
                } else {
                    String parkedText = text.substring(mAlachiqMakeLink.getBeginningPositionOfParkedText() - 1);
                    if (!parkedText.equals(mAlachiqMakeLink.getParkedText())) {
                        mAlachiqMakeLink.setEmptyText();
                    } else {
                        mAlachiqMakeLink.setTypedText(text);
                    }
                }
            } else {
                mAlachiqMakeLink.setTypedText(text);
            }

            mAlachiqMakeLink.addTextChangedListener(this);
        }
    }
}

公共类AlachiqMakeLink扩展了EditText{
私有静态最终字符串标记=AlachiqMakeLink.class.getSimpleName（）；
私有静态最终字符串默认值\u TEXT\u COLOR=“FFFFFF”；
私有字符串mParkedText=“”；
私有布尔值mIsBoldParkedText=true；
私有字符串mParkedTextColor=默认\u文本\u颜色；
私有字符串mParkedHintColor=默认值\文本\颜色；
私有字符串mText=null；
私有枚举类型状态{
开始，打字
}
私有类型状态mTypingState=TypingState.Start；
公共AlachiqMakeLink（上下文）{
超级（上下文）；
init（）；
}
公共AlachiqMakeLink（上下文、属性集属性）{
这（上下文，属性，0）；
}
公共AlachiqMakeLink（上下文上下文、属性集属性、int defStyleAttr）{
super（上下文、attrs、defStyleAttr）；
TypedArray a=context.ActainStyledAttributes（attrs，R.styleable.AlachiqMakeLink，defStyleAttr，0）；
mParkedText=a.getString（R.styleable.AlachiqMakeLink\u parkedText）；
如果（mParkedText==null）{
mParkedText=“”；
}
字符串提示=a.getString（R.styleable.AlachiqMakeLink\u parkedHint）；
mParkedTextColor=a.getString（R.styleable.AlachiqMakeLink\u parkedTextColor）；
如果（mParkedTextColor==null）{
mParkedTextColor=AlachiqMakeLink.DEFAULT\u TEXT\u COLOR；
}
mParkedHintColor=a.getString（R.styleable.AlachiqMakeLink\u parkedHintColor）；
如果（mParkedHintColor==null）{
mParkedHintColor=AlachiqMakeLink.DEFAULT\u TEXT\u COLOR；
}
mIsBoldParkedText=a.getBoolean（R.styleable.AlachiqMakeLink\u parkedTextBold，true）；
init（）；
if（提示！=null）{
设置占位符文本（提示）；
}
a、 回收（）；
}
私有void init（）{
mText=“”；
observeText（）；
mTypingState=TypingState.Start；
addTextChangedListener（新的ParkedTextViewWatcher（本））；
}
公共字符串getParkedText（）{
返回mParkedText；
}
private int getBeginingPositionofParkedText（）{
int position=mText.length（）-mParkedText.length（）；
如果（位置<0）{
返回0；
}
返回位置；
}
private void gotobeginningof markedtext（）{
setSelection（getBeginingPositionofParkedText（））；
}
私有字符串getTypedText（）{
if（多行文字结束符（mParkedText））{
返回mText.substring（0，getBeginningPositionOfParkedText（））；
}
返回多行文字；
}
私有void setTypedText（字符串typedText）{
mText=typedText；
observeText（）；
textChanged（）；
}
私有void setEmptyText（）{
setTypedText（“”）；
}
公共空集合占位符文本（字符串占位符文本）{
跨距提示=null；
字符串parkedTextColor=重新格式化颜色（mParkedTextColor）；
字符串parkedHintColor=重新格式化颜色（mParkedHintColor）；
if（mIsBoldParkedText）{
hint=Html.fromHtml（String.format（“%s%s”、parkedHintColor、占位符文本、parkedTextColor、mParkedText））；
}否则{
hint=Html.fromHtml（String.format（“%s%s”、parkedHintColor、占位符文本、parkedTextColor、mParkedText））；
}
super.setHint（hint）；
}
//更改TypedText时调用
私有字符串observeText（）{
return mText=getTypedText（）+mParkedText；
}
私有字符串重新格式化颜色（字符串颜色）{
if（颜色。起始带（“#”）的颜色）{
颜色=颜色。子字符串（1）；
}
如果（color.length（）>6）{
返回颜色。子字符串（2）；
}
返回颜色；
}
私有跨区getHtmlText（）{
字符串parkedTextColor=重新格式化颜色（mParkedTextColor）；
if（mIsBoldParkedText）{
返回Html.fromHtml（String.format（“%s%s”，parkedTextColor，getTypedText（），parkedTextColor，mParkedText））；
}
返回Html.fromHtml（String.format（“%s”，parkedTextColor，getTypedText（）+mParkedText））；
}
私有void textChanged（）{
开关（mTypingState）{
案件开始：
if（多行文字长度（）0）{
mIsDeleteText=true；
}否则{
mIsDeleteText=false；
}
}
@凌驾
公共无效后文本已更改（可编辑）{
removeTextChangedListener（这个）；
字符串text=s.toString（）；
如果（错误删除文本）{
if（text.length（）

您可以通过添加切换来强制显示或隐藏键盘

InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    if (imm.isActive()){
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    } else {
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }