Android 检查输入

在开发过程中，会经常遇到这样的需求：上面有很多的输入控件，等所有的输入都合法后，按钮才能自动变成enabled的状态，才能继续下一步的操作。

下面是一种用观察者模式实现的一种解决方案。

 button代码：

public class KWButton extends Button implements Observer {

    private LinkedHashSet<Verifiable> mVerifiers = new LinkedHashSet<Verifiable>();

    public KWButton(Context context) {
        super(context);
        initView();
    }

    public KWButton(Context context, AttributeSet attrs) {
        super(context, attrs);
        initView();
    }

    public KWButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        initView();
    }

    private void initView() {
        // 初始化view
    }

    /**
     * 添加观察者
     * 
     * @param verifier
     */
    public void observer(Verifiable verifier) {
        if (this.isEnabled()) {
            this.setEnabled(false);
        }

        // 校验：如果当前verifier属于view 但是 不可显示则不做监听
        if ((verifier instanceof View)
                && ((View) verifier).getVisibility() != View.VISIBLE) {
            update(null, null);
            return;
        }
        if (verifier != null && !mVerifiers.contains(verifier)) {
            mVerifiers.add(verifier);
            //精华所在
            verifier.addObserver(this);
        }

        update(null, null);
    }

    @Override
    public void setEnabled(boolean enabled) {
        super.setEnabled(enabled);
    }

    /**
     * 解除观察
     * 
     * @param verifier
     */
    public void removeObserver(Verifiable verifier) {

        if (verifier != null) {
            mVerifiers.remove(verifier);
            this.update(null, null);
        }
    }

    /**
     * 清空观察者
     */
    public void clearObserver() {
        if (!ListUtil.isEmpty(mVerifiers)) {
            mVerifiers.clear();
            mAutoPerformClick = false;
            this.update(null, null);
        }
    }

    @Override
    public void update(Observable observable, Object data) {
        if (mAutoPerformClick) {
            if (!ListUtil.isEmpty(mVerifiers)) {
                if (isVerify()) {
                    this.postDelayed(new Runnable() {

                        @Override
                        public void run() {
                            performClick();
                        }
                    }, PERFORM_DELAY_TIME);
                }
            }
        } else {
            for (Verifiable verifier : mVerifiers) {
                if (verifier.isBlank()) {
                    KWButton.this.setEnabled(false);
                    return;
                }
            }
            KWButton.this.setEnabled(true);
        }
    }

    /**
     * 是否已通过验证
     * 
     * @return
     */
    private boolean isVerify() {
        for (Verifiable verifier : mVerifiers) {
            if (!verifier.verify()) {
                return false;
            }
        }
        return true;
    }
}

校验接口：

/**
 * 校验接口
 * 
 */
public interface Verifiable {
    /**
     * 校验
     * 
     * @return
     */
    boolean verify();
    boolean isBlank();
    void addObserver(Observer obj);
}

输入控件：

/**
 * 输入控件
 */
public class NeedCheckInput extends EditText implements Verifiable {

    private Context mContext;
    /**
     * 校验
     */
    private Observer mVerifyObserver = null;

    public NeedCheckInput(Context context) {
        super(context);
        mContext = context;
        init();
    }

    public NeedCheckInput(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        init();
    }

    @SuppressLint("InflateParams")
    private void init() {
        // 初始化view 代码
    }
    /*    
               // 通知观察者，控件状态已经改变，update一次，就检查一次
                if (mVerifyObserver != null) {
                    mVerifyObserver.update(null, null);
                }
     */

    @Override
    public boolean verify() {
        //添加校验规则 true:校验通过  false:校验不通过
        return !TextUtils.isEmpty(this.getText().toString());
    }

    @Override
    public boolean isBlank() {
       return ....;
    }

    @Override
    public void addObserver(Observer obj) {
        mVerifyObserver = obj;
    }

}

示例代码：

KWButton button  = new KWButton(context);
NeedCheckInput input1 = new NeedCheckInput(context);
NeedCheckInput input2 = new NeedCheckInput(context);

button.addObserver(input1);
button.addObserver(input2);

这样就可以做到检查输入了。