两列不联动Dialog

底部弹出Dialog，Dialog里面带两个自定义滑轮选择器，可设置联动时请求网络数据。

1.自定义滑轮选择器

public class NewTwoLineWheelView<T> extends RelativeLayout {

    private WheelView mLeftWheel;
    private WheelView mRightWheel;

    private int textSize = 16;
    private int textColor = 0xFFAAAAAA;
    private int currentTextSize = 16;
    private int currentTextColor = 0xFF333333;

    private T leftCurrentValue;
    private T rightCurrentValue;
    private LeftWheelAdapter mLeftWheelAdapter;
    private RightWheelAdapter mRightWheelAdapter;
    private OnTwoLineWheelChangedListener<T> mOnTwoLineWheelChangedListener;

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

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

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

    private void init(Context context) {
        View.inflate(getContext(), R.layout.xw_view_two_line_picker, this);
        mLeftWheel = (WheelView) findViewById(R.id.xw_mWVLeft);
        mRightWheel = (WheelView) findViewById(R.id.xw_mWVRight);
        mLeftWheel.setWheelBackground(R.drawable.wheel_bg_light);
        mLeftWheel.setWheelForeground(R.drawable.wheel_val_light);
        mLeftWheel.setShadowColor(0x00aaaaaa, 0x00aaaaaa, 0x00aaaaaa);
        mLeftWheel.setVisibleItems(5);
        mRightWheel.setWheelBackground(R.drawable.wheel_bg_light);
        mRightWheel.setWheelForeground(R.drawable.wheel_val_light);
        mRightWheel.setShadowColor(0x00aaaaaa, 0x00aaaaaa, 0x00aaaaaa);
        mRightWheel.setVisibleItems(5);

        mLeftWheelAdapter = new LeftWheelAdapter(context);
        mLeftWheel.setViewAdapter(mLeftWheelAdapter);
        mRightWheelAdapter = new RightWheelAdapter(context);
        mRightWheel.setViewAdapter(mRightWheelAdapter);

        mLeftWheel.addChangingListener(wheelChangeListener);
        mRightWheel.addChangingListener(wheelChangeListener);
    }

    public void setTextSize(int textSize) {
        this.textSize = textSize;
    }

    public void setTextColor(int textColor) {
        this.textColor = textColor;
    }

    public void setCurrentTextSize(int currentTextSize) {
        this.currentTextSize = currentTextSize;
    }

    public void setCurrentTextColor(int currentTextColor) {
        this.currentTextColor = currentTextColor;
    }

    public void setLeftWheelDatas(List<WheelViewBean<T>> leftWheelDatas) {
        setLeftWheelDatas(leftWheelDatas, 0);
    }

    public void setLeftWheelDatas(List<WheelViewBean<T>> leftWheelDatas, int defaultLeftItem) {
        setLeftWheelDatas(leftWheelDatas, defaultLeftItem, 0);
    }

    public void setLeftWheelDatas(List<WheelViewBean<T>> leftWheelDatas, int defaultLeftItem, int defaultRightItem) {
        if (leftWheelDatas != null && !leftWheelDatas.isEmpty()) {
            leftCurrentValue = leftWheelDatas.get(defaultLeftItem).data;
            mLeftWheelAdapter.setDatas(leftWheelDatas);

            mLeftWheel.setCurrentItem(defaultLeftItem, true);
            mLeftWheel.invalidateWheel(true);
        }
    }

    public void setRightWheelDatas(List<WheelViewBean<T>> rightWheelDatas) {
        setRightWheelDatas(rightWheelDatas, 0);
    }

    public void setRightWheelDatas(List<WheelViewBean<T>> rightWheelDatas, int defaultRightItem) {
        if (rightWheelDatas != null && !rightWheelDatas.isEmpty()) {
            rightCurrentValue = rightWheelDatas.get(defaultRightItem).data;
            mRightWheelAdapter.setDatas(rightWheelDatas);
            mRightWheel.setCurrentItem(defaultRightItem, true);
            mRightWheel.invalidateWheel(true);
        }
    }

    private OnWheelChangedListener wheelChangeListener = new OnWheelChangedListener() {

        public void onChanged(WheelView wheel, int oldValue, int newValue) {
            if (wheel == mLeftWheel) {
                leftCurrentValue = mLeftWheelAdapter.getDatas().get(newValue).data;
                setRightWheelDatas(mLeftWheelAdapter.getDatas().get(newValue).childDatas);
                if (mOnTwoLineWheelChangedListener != null) {
                    mOnTwoLineWheelChangedListener.onLeftWheelChanged(mLeftWheel, mRightWheel, leftCurrentValue);
                }
            } else if (wheel == mRightWheel) {
                rightCurrentValue = mRightWheelAdapter.getDatas().get(newValue).data;
                if (mOnTwoLineWheelChangedListener != null) {
                    mOnTwoLineWheelChangedListener.onRightWheelChanged(mLeftWheel, mRightWheel, rightCurrentValue);
                }
            }
            wheel.invalidateWheel(true);
        }
    };

    public void setOnTwoLineWheelChangedListener(OnTwoLineWheelChangedListener<T> onTwoLineWheelChangedListener) {
        mOnTwoLineWheelChangedListener = onTwoLineWheelChangedListener;
    }

    public T getLeftCurrentValue() {
        return leftCurrentValue;
    }

    public T getRightCurrentValue() {
        return rightCurrentValue;
    }

    public interface OnTwoLineWheelChangedListener<T> {
        void onLeftWheelChanged(WheelView leftWheel, WheelView rightWheel, T data);
        void onRightWheelChanged(WheelView leftWheel, WheelView rightWheel, T data);
    }

    private class LeftWheelAdapter extends WheelBaseAdapter<WheelViewBean<T>> {

        public LeftWheelAdapter(Context context) {
            super(context);
        }

        public LeftWheelAdapter(Context context, List<WheelViewBean<T>> list) {
            super(context, list);
        }

        @Override
        protected CharSequence getItemText(int index) {
            if (mDatas != null) {
                return mDatas.get(index).name;
            }
            return null;
        }

        @Override
        protected void configureTextView(int index, TextView view) {
            view.setGravity(Gravity.CENTER);
            view.setLines(1);
            view.setIncludeFontPadding(false);
            if (currentItem.data == leftCurrentValue) {
                view.setTextColor(currentTextColor);
                view.setTextSize(currentTextSize);
            } else {
                view.setTextColor(textColor);
                view.setTextSize(textSize);
            }

            view.setPadding(LocalDisplay.dp2px(5), LocalDisplay.dp2px(4), LocalDisplay.dp2px(5), LocalDisplay.dp2px(4));
            view.setTypeface(Typeface.SANS_SERIF);
        }
    }

    private class RightWheelAdapter extends WheelBaseAdapter<WheelViewBean<T>> {

        public RightWheelAdapter(Context context) {
            super(context);
        }

        public RightWheelAdapter(Context context, List<WheelViewBean<T>> list) {
            super(context, list);
        }

        @Override
        protected CharSequence getItemText(int index) {
            if (mDatas != null) {
                return mDatas.get(index).name;
            }
            return null;
        }

        @Override
        protected void configureTextView(int index, TextView view) {
            view.setGravity(Gravity.CENTER);
            view.setLines(1);
            view.setIncludeFontPadding(false);
            if (currentItem.data == rightCurrentValue) {
                view.setTextColor(currentTextColor);
                view.setTextSize(currentTextSize);
            } else {
                view.setTextColor(textColor);
                view.setTextSize(textSize);
            }

            view.setPadding(LocalDisplay.dp2px(5), LocalDisplay.dp2px(4), LocalDisplay.dp2px(5), LocalDisplay.dp2px(4));
            view.setTypeface(Typeface.SANS_SERIF);
        }
    }
}

2.重写系统弹出的Dialog

public class BasicTwoLineWheelViewDialog<T> extends Dialog {

    private NewTwoLineWheelView<T> mPicker;
    private TextView mTvConfirm;
    private TextView mTvCancel;
    private OnSelectedListener<Object> mOnSelectedListener;

    public BasicTwoLineWheelViewDialog(@NonNull Context context) {
        this(context, R.style.BizcategoryDialogTheme);
    }

    public BasicTwoLineWheelViewDialog(@NonNull Context context, int themeResId) {
        super(context, R.style.BizcategoryDialogTheme);
        init(context);
    }

    private void init(Context context) {
        View view = LayoutInflater.from(context).inflate(R.layout.zeno_basic_two_line_wheelview_dialog, null);
        mTvCancel = (TextView) view.findViewById(R.id.xw_mTVCancel);
        mTvConfirm = (TextView) view.findViewById(R.id.xw_mTVConfirm);
        mPicker = (NewTwoLineWheelView<T>) view.findViewById(R.id.xw_mPicker);

        mTvCancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mOnSelectedListener != null) {
                    mOnSelectedListener.onCancel();
                }
                BasicTwoLineWheelViewDialog.this.dismiss();
            }
        });

        mTvConfirm.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mOnSelectedListener != null) {
                    mOnSelectedListener.onSelected(mPicker.getLeftCurrentValue(), mPicker.getRightCurrentValue());
                }
                BasicTwoLineWheelViewDialog.this.dismiss();
            }
        });

        Window window = this.getWindow();
        window.setWindowAnimations(R.style.bottomDialogWindowAnim); //设置窗口弹出动画
        setContentView(view);
        WindowManager.LayoutParams lp = window.getAttributes();
        lp.width = WindowManager.LayoutParams.MATCH_PARENT;
        lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
        lp.gravity = Gravity.BOTTOM;
        window.setAttributes(lp);
    }

    public void setLeftWheelDatas(List<WheelViewBean<T>> leftWheelDatas) {
        setLeftWheelDatas(leftWheelDatas, 0);
    }

    public void setLeftWheelDatas(List<WheelViewBean<T>> leftWheelDatas, int defaultLeftItem) {
        setLeftWheelDatas(leftWheelDatas, defaultLeftItem, 0);
    }

    public void setLeftWheelDatas(List<WheelViewBean<T>> leftWheelDatas, int defaultLeftItem, int defaultRightItem) {
        mPicker.setLeftWheelDatas(leftWheelDatas, defaultLeftItem, defaultRightItem);
    }

    public void setRightWheelDatas(List<WheelViewBean<T>> rightWheelDatas) {
        setRightWheelDatas(rightWheelDatas, 0);
    }

    public void setRightWheelDatas(List<WheelViewBean<T>> rightWheelDatas, int defaultRightItem) {
        mPicker.setRightWheelDatas(rightWheelDatas, defaultRightItem);
    }

    public void setOnSelectedListener(OnSelectedListener<Object> onSelectedListener) {
        mOnSelectedListener = onSelectedListener;
    }


    public NewTwoLineWheelView<T> getPicker() {
        return mPicker;
    }

    public interface OnSelectedListener<T> {

        void onSelected(T leftData, T RightData);

        void onCancel();
    }
}