时间,性别,选择器

package com.sclgxt.timepicker.widget;


import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;


import com.sclgxt.timepicker.R;




/**
 * Created by Sclgxt @ 2016/5/28
 */
public class WheelViews extends LinearLayout {
    private Map<String, Map<String, Object>> returndata;
    public static String SELECTEDINDEX = "selectedIndex";
    public static String ITEM = "item";
    private OnDataChangeListener onDataChangeListener;
    private int offset = 2;


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


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


    private interface OnWheelViewListener {
        void onSelected(int selectedIndex, String item);
    }


    public interface OnDataChangeListener {
        void onDataChange(Map<String, Map<String, Object>> data, String selectedkey);
    }


    public void setOnDataChangeListener(OnDataChangeListener onDataChangeListener) {
        this.onDataChangeListener = onDataChangeListener;
    }


    public void setData(final Map<String, List<String>> data) {
        if (data == null) {
            return;
        }
        Set<String> keySet = data.keySet();
        for (String key_keyset : keySet) {
            final Map<String, Object> selectmap = new HashMap<>();
            final String key = key_keyset + "";
            WheelView wheelView = new WheelView(getContext());
            this.addView(wheelView);
            wheelView.setmPadding(5);
            wheelView.setOffset(offset);
            List<String> list = data.get(key_keyset);
            wheelView.setItems(list);
            wheelView.setSeletion(0);
            selectmap.put(ITEM, list.get(0));
            returndata.put(key, selectmap);
            wheelView.setOnWheelViewListener(new OnWheelViewListener() {
                @Override
                public void onSelected(int selectedIndex, String item) {
                    selectmap.put(SELECTEDINDEX, selectedIndex);
                    selectmap.put(ITEM, item);
                    returndata.put(key, selectmap);
                    if (onDataChangeListener != null) {
                        onDataChangeListener.onDataChange(returndata, key);
                    }
                }
            });
            LayoutParams layoutParams = (LayoutParams) wheelView.getLayoutParams();
            layoutParams.width = 0;
            layoutParams.weight = 1;
            wheelView.setLayoutParams(layoutParams);
        }


    }




    public void init() {
        returndata = new HashMap<>();
    }


    class WheelView extends ScrollView {
        public final String TAG = WheelView.class.getSimpleName();
        private int selectColor = Color.parseColor("#26b14c");
        private Context context;
        private LinearLayout views;


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


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


        public WheelView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            init(context);
        }


        List<String> items;


        public void setItems(List<String> list) {
            if (null == items) {
                items = new ArrayList<>();
            }
            items.clear();
            items.addAll(list);


            // 前面和后面补全
            for (int i = 0; i < offset; i++) {
                items.add(0, "");
                items.add("");
            }


            initData();


        }




        public static final int OFF_SET_DEFAULT = 1;
        int offset = OFF_SET_DEFAULT; // 偏移量（需要在最前面和最后面补全）


        public void setOffset(int offset) {
            this.offset = offset;
        }


        int displayItemCount; // 每页显示的数量


        int selectedIndex = 1;




        private void init(Context context) {
            //去除滚不动再去滚动时出现的一个渐变色块
            setOverScrollMode(View.OVER_SCROLL_NEVER);
            this.context = context;


            // Log.d(TAG, "parent: " + this.getParent());
            this.setVerticalScrollBarEnabled(false);


            views = new LinearLayout(context);
            views.setOrientation(LinearLayout.VERTICAL);
            this.addView(views);


            scrollerTask = new Runnable() {


                public void run() {


                    int newY = getScrollY();
                    if (initialY - newY == 0) { // stopped
                        final int remainder = initialY % itemHeight;
                        final int divided = initialY / itemHeight;
                        if (remainder == 0) {
                            selectedIndex = divided + offset;


                            onSeletedCallBack();
                        } else {
                            if (remainder > itemHeight / 2) {
                                WheelView.this.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        WheelView.this.smoothScrollTo(0, initialY - remainder + itemHeight);
                                        selectedIndex = divided + offset + 1;
                                        onSeletedCallBack();
                                    }
                                });
                            } else {
                                WheelView.this.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        WheelView.this.smoothScrollTo(0, initialY - remainder);
                                        selectedIndex = divided + offset;
                                        onSeletedCallBack();
                                    }
                                });
                            }




                        }




                    } else {
                        initialY = getScrollY();
                        WheelView.this.postDelayed(scrollerTask, newCheck);
                    }
                }
            };




        }


        int initialY;


        Runnable scrollerTask;
        int newCheck = 50;


        public void startScrollerTask() {


            initialY = getScrollY();
            this.postDelayed(scrollerTask, newCheck);
        }


        private void initData() {
            displayItemCount = offset * 2 + 1;


            for (String item : items) {
                views.addView(createView(item));
            }


            refreshItemView(0);
        }


        int itemHeight = 0;
        int mTextSize = 20;
        float mPadding = 12;


        public void setmPadding(float mPadding) {
            this.mPadding = mPadding;
        }


        public void setmTextSize(int mTextSize) {
            this.mTextSize = mTextSize;
        }


        public void setSelectColor(int selectColor) {
            this.selectColor = getResources().getColor(selectColor);
        }


        private TextView createView(String item) {
            TextView tv = new TextView(context);
            tv.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
            tv.setSingleLine(true);
            tv.setTextSize(TypedValue.COMPLEX_UNIT_SP, mTextSize);
            tv.setText(item);
            tv.setGravity(Gravity.CENTER);
            int padding = dip2px(mPadding);
            tv.setPadding(padding, padding, padding, padding);
            if (0 == itemHeight) {
                itemHeight = getViewMeasuredHeight(tv);
                //   Log.d(TAG, "itemHeight: " + itemHeight);
                views.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, itemHeight * displayItemCount));
                LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) this.getLayoutParams();
                this.setLayoutParams(new LinearLayout.LayoutParams(lp.width, itemHeight * displayItemCount));
            }
            return tv;
        }




        @Override
        protected void onScrollChanged(int l, int t, int oldl, int oldt) {
            super.onScrollChanged(l, t, oldl, oldt);
            refreshItemView(t);
        }




        private void refreshItemView(int y) {
            int position = y / itemHeight + offset;
            int remainder = y % itemHeight;
            int divided = y / itemHeight;


            if (remainder == 0) {
                position = divided + offset;
            } else {
                if (remainder > itemHeight / 2) {
                    position = divided + offset + 1;
                }


            }


            int childSize = views.getChildCount();
            for (int i = 0; i < childSize; i++) {
                TextView itemView = (TextView) views.getChildAt(i);
                if (null == itemView) {
                    return;
                }
                if (position == i) {
                    itemView.setTextColor(selectColor);


                } else {
                    itemView.setTextColor(Color.parseColor("#bbbbbb"));
                }
                //-14241460
            }
        }


        /**
         * 获取选中区域的边界
         */
        int[] selectedAreaBorder;


        private int[] obtainSelectedAreaBorder() {
            if (null == selectedAreaBorder) {
                selectedAreaBorder = new int[2];
                selectedAreaBorder[0] = itemHeight * offset;
                selectedAreaBorder[1] = itemHeight * (offset + 1);
            }
            return selectedAreaBorder;
        }


        Paint paint;
        int viewWidth;


        @Override
        public void setBackgroundDrawable(Drawable background) {


            if (viewWidth == 0) {
                viewWidth = ((Activity) context).getWindowManager().getDefaultDisplay().getWidth();
                // Log.d(TAG, "viewWidth: " + viewWidth);
            }


            if (null == paint) {
                paint = new Paint();
                paint.setColor(getResources().getColor(R.color.c3));
                paint.setStrokeWidth(getResources().getDimension(R.dimen.dimen_1dp));
            }


            background = new Drawable() {
                @Override
                public void draw(Canvas canvas) {
                    canvas.drawLine(0, obtainSelectedAreaBorder()[0], viewWidth, obtainSelectedAreaBorder()[0], paint);
                    canvas.drawLine(0, obtainSelectedAreaBorder()[1], viewWidth, obtainSelectedAreaBorder()[1], paint);
                }


                @Override
                public void setAlpha(int alpha) {


                }


                @Override
                public void setColorFilter(ColorFilter cf) {


                }


                @Override
                public int getOpacity() {
                    return 0;
                }
            };




            super.setBackgroundDrawable(background);


        }


        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
            super.onSizeChanged(w, h, oldw, oldh);
            // Log.d(TAG, "w: " + w + ", h: " + h + ", oldw: " + oldw + ", oldh: " + oldh);
            viewWidth = w;
            setBackgroundDrawable(null);
        }


        /**
         * 选中回调
         */
        private void onSeletedCallBack() {
            if (null != onWheelViewListener) {
                onWheelViewListener.onSelected(selectedIndex, items.get(selectedIndex));
            }


        }


        public void setSeletion(int position) {
            final int p = position;
            selectedIndex = p + offset;
            this.post(new Runnable() {
                @Override
                public void run() {
                    WheelView.this.smoothScrollTo(0, p * itemHeight);
                }
            });


        }




        @Override
        public void fling(int velocityY) {
            super.fling(velocityY / 3);
        }


        @Override
        public boolean onTouchEvent(MotionEvent ev) {
            if (ev.getAction() == MotionEvent.ACTION_UP) {


                startScrollerTask();
            }
            return super.onTouchEvent(ev);
        }


        private OnWheelViewListener onWheelViewListener;




        public void setOnWheelViewListener(OnWheelViewListener onWheelViewListener) {
            this.onWheelViewListener = onWheelViewListener;
        }


        private int dip2px(float dpValue) {
            final float scale = context.getResources().getDisplayMetrics().density;
            return (int) (dpValue * scale + 0.5f);
        }


        private int getViewMeasuredHeight(View view) {
            int width = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
            int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
            view.measure(width, expandSpec);
            return view.getMeasuredHeight();
        }
    }


    public Map<String, Map<String, Object>> getReturndata() {
        return returndata;
    }


    public void setOffset(int offset) {
        if (offset == 0) {
            return;
        }
        this.offset = offset;
    }

}

效果图

下载链接http://download.csdn.net/detail/sclgxt/9562583