Android 仿ios 实现地址选择

最新推荐文章于 2023-07-01 20:52:15 发布
最新推荐文章于 2023-07-01 20:52:15 发布
阅读量775 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22060403/article/details/79710125
版权 
//  滚轮控件的RecycleView
public class WheelRecyclerView extends RecyclerView {

    //默认参数
    private final int DEFAULT_WIDTH = Util.dp2px(160);

    private final int DEFAULT_ITEM_HEIGHT = Util.dp2px(50);

    private final int DEFAULT_SELECT_TEXT_COLOR = Color.BLACK;

    private final int DEFAULT_UNSELECT_TEXT_COLOR = getResources().getColor(R.color.color136);

    private final int DEFAULT_SELECT_TEXT_SIZE = Util.sp2px(14);

    private final int DEFAULT_UNSELECT_TEXT_SIZE = Util.sp2px(14);

    private final int DEFAULT_OFFSET = 1;

    private final int DEFAULT_DIVIDER_WIDTH = ViewGroup.LayoutParams.MATCH_PARENT;

    private final int DEFAULT_DIVIDER_HEIGHT = Util.dp2px(1);

    private final int DEFAULT_DIVIVER_COLOR = getResources().getColor(R.color.color136);


    private WheelAdapter mAdapter;

    private LinearLayoutManager mLayoutManager;

    private List<String> mDatas; //数据

    private int mItemHeight; //选项高度

    private int mOffset; //处于中间的item为选中，在头尾需补充 offset个空白view，可显示的item数量=2*offset+1

    private int mSelectTextColor; //选中item的文本颜色

    private int mUnselectTextColor; //非选中item的文本颜色

    private float mSelectTextSize; //选中item的文本大小

    private float mUnselectTextSize;//非选中item的文本大小

    private float mDividerWidth;//分割线的宽度

    private float mDividerHeight;//分割线高度

    private int mDividerColor;//分割线颜色

    private Paint mPaint;//绘制分割线的paint

    private OnSelectListener mOnSelectListener;

    private int mSelected;
    private Context mContext;

    public WheelRecyclerView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.WheelRecyclerView);

        mItemHeight = (int) ta.getDimension(R.styleable.WheelRecyclerView_itemHeight, DEFAULT_ITEM_HEIGHT);
        mSelectTextColor = ta.getColor(R.styleable.WheelRecyclerView_selectTextColor, DEFAULT_SELECT_TEXT_COLOR);
        mUnselectTextColor = ta.getColor(R.styleable.WheelRecyclerView_unselectTextColor, DEFAULT_UNSELECT_TEXT_COLOR);
        mSelectTextSize = ta.getDimension(R.styleable.WheelRecyclerView_selectTextSize, DEFAULT_SELECT_TEXT_SIZE);
        mUnselectTextSize = ta.getDimension(R.styleable.WheelRecyclerView_unselectTextSize, DEFAULT_UNSELECT_TEXT_SIZE);
        mOffset = ta.getInteger(R.styleable.WheelRecyclerView_wheelOffset, DEFAULT_OFFSET);
        mDividerWidth = ta.getDimension(R.styleable.WheelRecyclerView_dividerWidth, DEFAULT_DIVIDER_WIDTH);
        mDividerHeight = ta.getDimension(R.styleable.WheelRecyclerView_dividerHeight, DEFAULT_DIVIDER_HEIGHT);
        mDividerColor = ta.getColor(R.styleable.WheelRecyclerView_dividerColor, DEFAULT_DIVIVER_COLOR);

        ta.recycle();

        mDatas = new ArrayList<>();
        mPaint = new Paint();
        mPaint.setColor(mDividerColor);
        mPaint.setStrokeWidth(mDividerHeight);

        init();
    }

    private void init() {
        mLayoutManager = new LinearLayoutManager(getContext());
        setLayoutManager(mLayoutManager);
        if (mDividerColor != Color.TRANSPARENT && mDividerHeight != 0 && mDividerWidth != 0) {
            addItemDecoration(new DividerItemDecoration());
        }
        mAdapter = new WheelAdapter();
        setAdapter(mAdapter);
        addOnScrollListener(new OnWheelScrollListener());

    }

    @Override
    protected void onMeasure(int widthSpec, int heightSpec) {
        int width;
        int height;
        int heightSpecSize = MeasureSpec.getSize(heightSpec);
        int heightSpecMode = MeasureSpec.getMode(heightSpec);
        //当指定了控件高度时，每个item平分整个高度，控件无指定高度时，默认高度为可视item的累加高度
        switch (heightSpecMode) {
            case MeasureSpec.EXACTLY:
                height = heightSpecSize;
                mItemHeight = height / (mOffset * 2 + 1);
                break;
            default:
                height = (mOffset * 2 + 1) * mItemHeight;
                break;
        }
        width = getDefaultSize(DEFAULT_WIDTH, widthSpec);
        if (mDividerWidth == DEFAULT_DIVIDER_WIDTH) {
            mDividerWidth = width;
        }
        setMeasuredDimension(width, height);
    }

    public void setData(List<String> datas) {
        if (datas == null) {
            return;
        }
        mDatas.clear();
        mDatas.addAll(datas);
        mAdapter.notifyDataSetChanged();
        setSelect(0);
        scrollTo(0,0);
    }

    public void setOnSelectListener(OnSelectListener listener) {
        mOnSelectListener = listener;
    }

    public void setSelect(int position) {
        mSelected = position;
        mLayoutManager.scrollToPosition(mSelected);
    }

    public int getSelected() {
        return mSelected;
    }

    private class WheelAdapter extends Adapter<WheelAdapter.WheelHolder> {

        // 动画转变线
        private float mTurningLine;
        // Recyclerview视图
        private RecyclerView mParentView;

        @Override
        public WheelHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            mParentView = (RecyclerView) parent;
            // 以recyclerview中等高度水平线作为动画转变的标准
            mTurningLine = 300;

            WheelHolder holder = new WheelHolder(LayoutInflater.from(getContext()).inflate(R.layout.item_wheel, parent, false));
            holder.name.getLayoutParams().height = mItemHeight;
            return holder;
        }

        @Override
        public int getItemCount() {
            return mDatas.size() == 0 ? 0 : mDatas.size() + mOffset * 2;
        }

        @Override
        public void onBindViewHolder(WheelHolder holder, int position) {
            //头尾填充offset个空白view以使数据能处于中间选中状态
            if (position < mOffset || position > mDatas.size() + mOffset - 1) {
                holder.name.setText("");
            } else {
                holder.name.setText(mDatas.get(position - mOffset));
            }


        }

        class WheelHolder extends ViewHolder {
            // 视图容器
            private ViewGroup containerView;
            TextView name;
            // 子项顶部所在的位置（像素点）
            private float itemTop = Integer.MIN_VALUE;

            public WheelHolder(View itemView) {
                super(itemView);
                name = (TextView) itemView.findViewById(R.id.tv_name);
            }
        }
    }

    private class OnWheelScrollListener extends OnScrollListener {
        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            super.onScrollStateChanged(recyclerView, newState);
            if (newState == RecyclerView.SCROLL_STATE_IDLE) {
                //当控件停止滚动时，获取可视范围第一个item的位置，滚动调整控件以使选中的item刚好处于正中间
                int firstVisiblePos = mLayoutManager.findFirstVisibleItemPosition();
                if (firstVisiblePos == RecyclerView.NO_POSITION) {
                    return;
                }
                Rect rect = new Rect();
                mLayoutManager.findViewByPosition(firstVisiblePos).getHitRect(rect);
                if (Math.abs(rect.top) > mItemHeight / 2) {
                    smoothScrollBy(0, rect.bottom);
                    mSelected = firstVisiblePos + 1;

                } else {
                    smoothScrollBy(0, rect.top);
                    mSelected = firstVisiblePos;
                }
                if (mOnSelectListener != null) {
                    mOnSelectListener.onSelect(mSelected, mDatas.get(mSelected));
                }

            }
        }

        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            super.onScrolled(recyclerView, dx, dy);
            setSelectedItem();
        }
    }

    private void setSelectedItem(){
        //获取可视范围的第一个控件的位置
        int firstVisiblePos = mLayoutManager.findFirstVisibleItemPosition();
        if (firstVisiblePos == RecyclerView.NO_POSITION) {
            return;
        }
        Rect rect = new Rect();
        mLayoutManager.findViewByPosition(firstVisiblePos).getHitRect(rect);
        //被选中item是否已经滑动超出中间区域
        boolean overScroll = Math.abs(rect.top) > mItemHeight / 2 ? true : false;
        //更新可视范围内所有item的样式
        for (int i = 0; i < 1 + mOffset * 2; i++) {
            TextView item;
            if (overScroll) {
                item = (TextView) mLayoutManager.findViewByPosition(firstVisiblePos + i + 1);
            } else {
                item = (TextView) mLayoutManager.findViewByPosition(firstVisiblePos + i);
            }

            if (i == mOffset) {
                item.setTextColor(mSelectTextColor);
                item.setTextSize(TypedValue.COMPLEX_UNIT_PX, mSelectTextSize);
            } else {
                item.setTextColor(mUnselectTextColor);
                item.setTextSize(TypedValue.COMPLEX_UNIT_PX, mUnselectTextSize);
            }
        }
    }

    private class DividerItemDecoration extends ItemDecoration {
        @Override
        public void onDrawOver(Canvas c, RecyclerView parent, State state) {
            //绘制分割线
            float startX = getMeasuredWidth() / 2 - mDividerWidth / 2;
            float topY = mItemHeight * mOffset;
            float endX = getMeasuredWidth() / 2 + mDividerWidth / 2;
            float bottomY = mItemHeight * (mOffset + 1);

            c.drawLine(startX, topY, endX, topY, mPaint);
            c.drawLine(startX, bottomY, endX, bottomY, mPaint);
        }
    }
    public interface OnSelectListener {
        void onSelect(int position, String data);
    }

}
 

public class CityPicker implements PopupWindow.OnDismissListener, View.OnClickListener {
    private OnCitySelectListener mOnCitySelectListener;
    private PopupWindow mPickerWindow;
    private View mParent;
    private WheelRecyclerView mProvinceWheel;
    private WheelRecyclerView mCityWheel;
    private WheelRecyclerView mCountyWheel;
    private Activity mContext;
    private List<String> provinces = new ArrayList<>();
    private List<String> citys = new ArrayList<>();
    private List<String> areas = new ArrayList<>();
    List<Province> provinceList;
    List<City> listcity;
    List<String> listarea;

    public CityPicker(Activity context, View parent) {
        mContext = context;
        mParent = parent;
        //初始化选择器
        View pickerView = LayoutInflater.from(context).inflate(R.layout.city_picker, null);
        mProvinceWheel = (WheelRecyclerView) pickerView.findViewById(R.id.wheel_province);
        mCityWheel = (WheelRecyclerView) pickerView.findViewById(R.id.wheel_city);
        mCountyWheel = (WheelRecyclerView) pickerView.findViewById(R.id.wheel_county);
        pickerView.findViewById(R.id.tv_exit).setOnClickListener(this);
        pickerView.findViewById(R.id.tv_ok).setOnClickListener(this);
        mPickerWindow = new PopupWindow(pickerView, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, true);
        mPickerWindow.setBackgroundDrawable(new ColorDrawable(Color.WHITE));
        mPickerWindow.setFocusable(true);
        mPickerWindow.setAnimationStyle(R.style.CityPickerAnim);
        mPickerWindow.setOnDismissListener(this);
        initData();
    }
    /**
     * 初始化城市数据
     */
    private void initData() {
        provinceList=new ArrayList<>();
        if (provinceList.size()>0){
            provinceList.clear();
        }
        provinceList = readFromAssets(mContext);
        citys.clear();
        List<City> list = provinceList.get(0).getList();
        citys.clear();
        for (City bean : list) {

            citys.add(bean.getName());
            mCityWheel.setData(citys);
        }
         listarea = provinceList.get(0).getList().get(0).getList();
        areas.clear();
        for (String str : listarea) {
            areas.add(str);
            mCountyWheel.setData(areas);
        }
        for (Province bean : provinceList) {
            provinces.add(bean.getName());
        }
        mProvinceWheel.setData(provinces);
        mProvinceWheel.setOnSelectListener(new WheelRecyclerView.OnSelectListener() {
            @Override
            public void onSelect(int position, String data) {
                listcity = provinceList.get(position).getList();
                if (citys.size() > 0) {
                    citys.clear();
                }
                for (City bean : listcity) {
                    citys.add(bean.getName());
                }
                mCityWheel.setData(citys);
                if (listcity == null || listcity.size() == 0) {
                    if (areas.size() > 0) {
                        areas.clear();
                    }
                    mCountyWheel.setData(areas);
                }
                if (listcity.size() > 0) {
                    listarea = listcity.get(0).getList();
                    if (areas.size() > 0) {
                        areas.clear();
                    }
                    for (String str : listarea) {
                        areas.add(str);
                    }
                    mCountyWheel.setData(areas);
                }
            }
        });
        mCityWheel.setOnSelectListener(new WheelRecyclerView.OnSelectListener() {
            @Override
            public void onSelect(int position, String data) {
                listarea = listcity.get(position).getList();
                if (areas.size() > 0) {
                    areas.clear();
                }
                for (String str : listarea) {
                    areas.add(str);
                }
                mCountyWheel.setData(areas);
            }
        });
    }


    /**
     * 弹出Window时使背景变暗
     *
     * @param alpha
     */
    private void backgroundAlpha(float alpha) {
        Window window = mContext.getWindow();
        WindowManager.LayoutParams lp = window.getAttributes();
        lp.alpha = alpha;
        window.addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
        window.setAttributes(lp);
    }

    public CityPicker setOnCitySelectListener(OnCitySelectListener listener) {
        mOnCitySelectListener = listener;
        return this;
    }

    public void show() {
        backgroundAlpha(0.5f);
        mPickerWindow.showAtLocation(mParent, Gravity.BOTTOM, 0, 0);
    }

    @Override
    public void onDismiss() {
        backgroundAlpha(1f);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.tv_ok:
                if (mOnCitySelectListener != null) {
                    String provinceName = provinces.get(mProvinceWheel.getSelected());
                    String cityName = "", countyName = "";
                    if (citys.size() > 0) {
                        cityName = citys.get(mCityWheel.getSelected());
                    }
                    if (areas.size() > 0) {
                        countyName = areas.get(mCountyWheel.getSelected());
                    }
                    mOnCitySelectListener.onCitySelect(provinceName, cityName, countyName);
                    mPickerWindow.dismiss();
                }
                break;
            case R.id.tv_exit:
                mPickerWindow.dismiss();
                break;
        }
    }
    public interface OnCitySelectListener {
        void onCitySelect(String province, String city, String county);
    }
 

 

 

 

public List<Province> readFromAssets(Context context) {
    List<Province> list = null;
    try {
        list = new ArrayList<>();
        InputStream inputStream = context.getAssets().open("province.json");
        String text = readTextFromSDcard(inputStream);
        inputStream.close();

        JSONArray jsonArray = new JSONArray(text);
        for (int i = 0; i < jsonArray.length(); i++) {
            Province province = new Province();
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            province.setName(jsonObject.get("name") + "");
            JSONArray jsonArray1 = jsonObject.getJSONArray("city");
            List<City> cityList = new ArrayList<>();

            for (int j = 0; j < jsonArray1.length(); j++) {
                JSONObject object = jsonArray1.getJSONObject(j);
                City city = new City();

                city.setName(object.get("name") + "");
                JSONArray jsonArray2 = object.getJSONArray("area");

                List<String> list1 = new ArrayList<>();
                for (int m = 0; m < jsonArray2.length(); m++) {
                    String strlist = jsonArray2.getString(m);
                    list1.add(strlist);
                }

                city.setList(list1);
                cityList.add(city);
            }
            province.setList(cityList);
            list.add(province);

        }
    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return list;
}

private String readTextFromSDcard(InputStream is) {
    StringBuffer buffer = null;
    try {
        InputStreamReader reader = new InputStreamReader(is, "utf-8");
        BufferedReader bufferedReader = new BufferedReader(reader);
        buffer = new StringBuffer("");
        String str;
        while ((str = bufferedReader.readLine()) != null) {
            buffer.append(str);
            buffer.append("\n");
        }
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return buffer.toString();
}
 

 

 

 

布局文件
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:orientation="vertical">

    <FrameLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <TextView
            android:id="@+id/tv_exit"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="start"
            android:background="?selectableItemBackgroundBorderless"
            android:gravity="center"
            android:padding="14dp"
            android:text="取消"
            android:textColor="@color/color136"
            android:textSize="16sp" />

        <TextView
            android:id="@+id/tv_title"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:background="?selectableItemBackgroundBorderless"
            android:gravity="center"
            android:padding="14dp"
            android:text="城市选择"
            android:textColor="@color/color0"
            android:textSize="16sp" />

        <TextView
            android:id="@+id/tv_ok"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="end"
            android:background="?selectableItemBackgroundBorderless"
            android:gravity="center"
            android:padding="14dp"
            android:text="确定"
            android:textColor="@color/color136"
            android:textSize="16sp" />
    </FrameLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"

        android:orientation="horizontal">

        <com.wf.kdb.customview.citypickerview.WheelRecyclerView
            android:id="@+id/wheel_province"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            app:dividerWidth="80dp" />

        <com.wf.kdb.customview.citypickerview.WheelRecyclerView
            android:id="@+id/wheel_city"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            app:dividerWidth="80dp" />

        <com.wf.kdb.customview.citypickerview.WheelRecyclerView
            android:id="@+id/wheel_county"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            app:dividerWidth="80dp" />
    </LinearLayout>
</LinearLayout>


 



                

        

        

    

  


    

      

        

            

              
                
                  一个在程序员路上前进的码农
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
android地址选择器

				
			

			

				

					07-27
				

			

		

		

			
				
1.省,市，区三级关联
2.地址数据本地化
3.自定义对话框
4.支付从xml文件，或对象文件加载
部分代码：
package com.demo.selector;


import java.io.InputStream;

import com.address.selector.City;
import com.address.selector.Country;
import com.address.selector.Province;
import com.address.selector.Region;
import com.demo.address.R;

import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.Spinner;
import android.widget.AdapterView.OnItemSelectedListener;

public class AddressSelectorDialog extends BaseDialog {
	/**省类型*/
	private static final int INDEX_PROVINCE = 1;
	
	/**城市类型*/
	private static final int INDEX_CITY = 2;
	
	/**区县类型*/
	private static final int INDEX_REGION = 3;
	
	private static Country china = null;
	
	private Spinner spnProvince = null;
	private Spinner spnCity = null;
	private Spinner spnRegion = null;
	
	private ArrayAdapter dptProvince = null;
	private ArrayAdapter dptCity = null;
	private ArrayAdapter dptRegion = null;
	
	private SpinnerSelectedListener proListener = new SpinnerSelectedListener();
	private SpinnerSelectedListener cityListener = new SpinnerSelectedListener();
	private SpinnerSelectedListener regionListener = new SpinnerSelectedListener();
	
	//当前选择地区的索引值
	private int provinceId = -1;
	private int cityId = -1;
	private int regionId = -1;
	
	/**选择按钮*/
	private Button btnSelect = null;
	
	/**回调用事件*/
	private OnSelectorCancel selectorCancel = null;
	
	@Override
	public void init(Context context) {
		// TODO Auto-generated method stub
		this.context = context;
		dialog = new Dialog(this.context,R.style.CustomDialog);
		dialog.setContentView(R.layout.adress_selector);
		
		spnProvince = (Spinner)dialog.findViewById(R.id.spin_province);
		spnProvince.setTag(new Integer(INDEX_PROVINCE));
		
		spnCity = (Spinner)dialog.findViewById(R.id.spin_city);
		spnCity.setTag(new Integer(INDEX_CITY));
		
		spnRegion = (Spinner)dialog.findViewById(R.id.spin_region);
		spnRegion.setTag(new Integer(INDEX_REGION));
		
		btnSelect = (Button)dialog.findViewById(R.id.btn_select);
		btnSelect.setOnClickListener(new OnClickListener(){

			@Override
			public void onClick(View arg0) {
				// TODO Auto-generated method stub
				selectAddress();
			}
			
		});
		
		//当对话框隐藏后调用[回调事件]
		dialog.setOnCancelListener(new OnCancelListener(){

			@Override
			public void onCancel(DialogInterface arg0) {
				// TODO Auto-generated method stub
				if (selectorCancel != null) {
					String proName = "";
					String cityName = "";
					String regName = "";
					try {
						Province tmpPro = china.provinceLst.get(provinceId);
						proName = tmpPro.areaName;
						
						City tmpCity = tmpPro.cityLst.get(cityId);
						cityName = tmpCity.areaName;
						
						Region tmpReg = tmpCity.regionLst.get(regionId);
						regName = tmpReg.areaName;
					} catch (Exception e) {
						android.util.Log.e("selectorCancel???", e.getMessage());
					}
					selectorCancel.onSelectorResult(proName, cityName, regName);
				}
			}
			
		});
		
		//加载数据
		if (china == null) {
			loadCountryAddressData();
		}
		
		//加载完后,初始化适配器
		initAdapters();
	}

	@Override
	public void update(Object obj) {
		// TODO Auto-generated method stub
		
	}

	private void loadCountryAddressData() {
		try {
			/**
			 * 反序化的包名,类名,版本ID必须一致,否则ClassNotFoundException
			 */
			InputStream stream = this.context.getAssets().open("china-city.obj");
			china = Country.loadFromStream(stream);
			//mHandler.sendEmptyMessage(0);
		} catch (Exception e) {
			android.util.Log.e("error", e.getMessage());
		}
	}
	
	class SpinnerSelectedListener implements OnItemSelectedListener{

		@Override
		public void onItemSelected (AdapterView parent, View view, 
				int position, long id)  {
			// TODO Auto-generated method stub
			//android.util.Log.i("", String.format("[pos=%d]",position));
            int index = (Integer)parent.getTag();
            //ArrayAdapter obj = (ArrayAdapter)(parent.getAdapter());
            //String value = obj.getItem(position);
            //android.util.Log.i("", "value=" + value);
            
            if (index == INDEX_PROVINCE) {
            	provinceId = position;
            	if (isValideProvinceIndex(provinceId)) {
            		//改变城市选择
            		Province tmpProvince = china.provinceLst.get(provinceId);
            		String lstNames[] = tmpProvince.listNames();
            		if (lstNames == null) { //没有城市,当然没区县
            			provinceId = -1;
            			spnCity.setVisibility(View.INVISIBLE);
            			regionId = -1;
            			spnRegion.setVisibility(View.INVISIBLE);
            			return ;
            		} else {
            			if (spnCity.getVisibility() == View.INVISIBLE) {
            				spnCity.setVisibility(View.VISIBLE);
            			}
            			if (spnRegion.getVisibility() == View.INVISIBLE) {
            				spnRegion.setVisibility(View.INVISIBLE);
            			}
            		}
            		dptCity = new ArrayAdapter(context,
            				      android.R.layout.simple_spinner_item,
            				      lstNames);
            		dptCity.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            		
            		spnCity.setAdapter(dptCity);
            		spnCity.setOnItemSelectedListener(cityListener);
            	}
            } else if (index == INDEX_CITY) {
            	cityId = position;
            	if (isValideCityIndex(provinceId,cityId)) {
            		//改变区选择
            		Province tmpProvince = china.provinceLst.get(provinceId);
            		City tmpCity = tmpProvince.cityLst.get(cityId);
            		String lstNames[] = tmpCity.listNames();
            		if (lstNames == null) { //没有区县
            			regionId = -1;
            			spnRegion.setVisibility(View.INVISIBLE);
            			return ;
            		} else if (spnRegion.getVisibility() == View.INVISIBLE) {
            			spnRegion.setVisibility(View.VISIBLE);
            		}
            		dptRegion = new ArrayAdapter(context,
          				      android.R.layout.simple_spinner_item,
          				      lstNames);
            		dptRegion.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
              		
            		spnRegion.setAdapter(dptRegion);
              		spnRegion.setOnItemSelectedListener(regionListener);
            	}
            	
            } else if (index == INDEX_REGION) {
            	regionId = position;
            }
		}

		@Override
		public void onNothingSelected(AdapterView parent) {
			// TODO Auto-generated method stub
		}
		
	}
	
	private void initAdapters() {
		dptProvince = new ArrayAdapter(this.context,
				  android.R.layout.simple_spinner_item,
				  china.listNames());
		//设置下拉列表的风格
		dptProvince.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
		//设置适配器
		spnProvince.setAdapter(dptProvince);
		//设置侦听事件
		spnProvince.setOnItemSelectedListener(proListener);
	}
	
	private boolean isValideProvinceIndex(int index) {
		return (china != null) &&  (index >= 0 && index = 0) &&
					(china.provinceLst.get(provinceIndex).cityLst.size() > cityIndex);
		}
		return false;
	}
	
	private void selectAddress() {
		hide();
	}
	
	/**
	 * 调协回调事件
	 * @param selectorCancel
	 */
	public void setOnSelectorCancel(OnSelectorCancel selectorCancel) {
		this.selectorCancel = selectorCancel;
	}
	
	/**
	 * 选择器关闭后,调用回调事件接口
	 */
	public interface OnSelectorCancel {
		/**
		 * @param proName 省份名
		 * @param cityName 城市名
		 * @param regName 区县名
		 */
		public void onSelectorResult(String proName,String cityName,String regName);
	};
}

			
		

	



                

            
              



	

		

			

				
					
安卓仿ios选择日期和地区 (新)

				
			

			

				

					03-02
				

			

		

		

			
				
安卓仿ios选择日期和地区 (新)

			
		

	



              


  
              

                


	

		

			

				
					
Android省市区三级联动滚轮选择——仿IOS效果

				
			

			

				

					08-31
				

			

		

		

			
				
Android省市区三级联动滚轮选择——仿IOS效果

			
		

	





	

		

			

				
					
仿IOS地址选择器和日期选择器

				
			

			

				

					02-05
				

			

		

		

			
				
之前做了一个仿IOS的日期选择器，最近的项目中又用到了地址选择器，所有的UI设计都是以IOS为准设计的，所以还要自己写一个，什么时候能以我大安卓为准设计，让IOS的自定义去啊。附上Demo源码，辛辛苦苦写的，各位猿和媛们不要吝啬你们的积分啊！

			
		

	



		

			
		



	

		

			

				
					
在android上实现仿照iOS搜索栏 居中效果，点击到最左边的demo eclipse项目

				
			

			

				

					05-26
				

			

		

		

			
				
在android上实现仿照iOS搜索栏 居中效果，点击到最左边的demo eclipse项目

			
		

	





	

		

			

				
					
Android仿IOS10圆盘时间选择器

				
			

			

				

					08-27
				

			

		

		

			
				
总的来说，实现Android仿iOS10圆盘时间选择器需要对Android图形绘制、手势识别以及几何变换有深入理解。通过这样的组件，开发者可以为用户带来更直观、友好的时间选择体验，同时也能提高应用的整体品质感。对于...

			
		

	





	

		

			

				
					
Android仿ios实现时间选择

				
			

			

				

					04-02
				

			

		

		

			
				
标题“Android仿ios实现时间选择”指的是在Android应用程序中创建一个功能类似于iOS时间选择器的组件。  iOS的时间选择器通常是一个半透明的弹出窗口，包含小时和分钟的滚动选择器，用户可以通过滚动选择他们想要的...

			
		

	





	

		

			

				
					
Android 仿IOS3D滚轮选择器

				
			

			

				

					04-14
				

			

		

		

			
				
"Android 仿IOS3D滚轮选择器"就是这样一个例子，它试图在Android平台上模仿iOS系统的三维滚轮选择器效果，以创建一个类似对话框的组件。这个组件能够帮助用户通过滚动和点击来选取特定的数据，适用于日期选择、选项...

			
		

	





	

		

			

				
					
Android高仿IOS 滚轮选择控件

				
			

			

				

					09-01
				

			

		

		

			
				
根据提供的文件信息，我们可以整理出一系列关于Android开发中高仿IOS风格的滚轮选择控件的知识点。  首先，我们需要了解什么是滚轮选择控件（WheelPicker或WheelView）。在Android开发中，这种控件模拟了现实世界中...

			
		

	





	

		

			

				
					
Android仿ios加载loading菊花图效果

				
			

			

				

					08-26
				

			

		

		

			
				
Android仿ios加载loading菊花图效果是指在Android应用程序中实现类似iOS的loading菊花图效果，该效果可以通过使用ProgressBar和drawable文件来实现。下面将详细介绍该效果的实现方法。   progressBar与drawable文件 ...

			
		

	





	

		

			

				
					
Android地址选择控件库以及示例

				
			

			

				

					08-22
				

			

		

		

			
				
android的地区选择，这个实在是太常见了，比如淘宝下单后的填写地址里面也有地区选择功能，微信里面也有收货地址，再者一些app的定位选择等等。

			
		

	





	

		

			

				
					
仿iOS的PickerView控件，有时间选择和地点选择并支持一二三级联动效果

				
			

			

				

					12-12
				

			

		

		

			
				
仿iOS的PickerView控件，有时间选择和地点选择并支持一二三级联动效果，超酷炫实用的安卓特效

			
		

	





	

		

			

				
					
android全国地区选择

				
			

			

				

					08-04
				

			

		

		

			
				
本地json文件集合，实现android全国地区三级省市区选择。

			
		

	





	

		

			

				
					
使用Android-PickerView实现地址选择器时间选择器

					
热门推荐

				
			

			

				

					trebleZ的博客
				

				

					12-21
					
					1万+
					
				

			

		

		

			
				
这里贡献下我使用Android-PickerView实现地址选择器遇到的坑，算是一个笔记。首先要吐槽下后台接口，为了实现移动端和web端的统一（ps:可能他没搞过后台接口），修改地址的时候本来要用下拉框。。。我去，后面ios的大兄弟苦苦哀求，改成了他们ios的PickerView,就是地址选择联动的，我一想也可以，不是有个大兄弟老早就封装了精仿这个PickerView吗，美美的~可是有点曲折

			
		

	





	

		

			

				
					
Android 仿iOS头像选择效果

				
			

			

				

					cndoom的专栏
				

				

					08-24
					
					519
					
				

			

		

		

			
				
不玩套路，先上效果。觉得好的在到下面找下载的地址.

欢迎加入QQ群一起讨论：193794648


























下载地址：  https://pan.baidu.com/s/1bp0vzdX 密码: 283n

在线观看：http://www.cniao5.com/course/10080

			
		

	





	

		

			

				
					
仿iOS滚轮选择器，目前最流畅，最好用，最接近iOS原生的开源控件

				
			

			

				

					you943047219的博客
				

				

					08-04
					
					8800
					
				

			

		

		

			
				
这几天因为公司的一个项目需要，2级联动，iOS样式滚轮，众所周知，Android端没有这样的原生控件，如图， 
 
目前来说，这个开源控件具有的优势是， 
1. 高自由度 如果需要省市，时间等这类，网上有很多，转看这个 
 https://github.com/saiwu-bigkoo/Android-PickerView 
2.  简洁，简单 
3. 用法说明<LinearLayout

			
		

	





	

		

			

				
					
RecyclerView 实现WheelView和省市区多级联动

				
			

			

				

					maniuT的博客
				

				

					07-01
					
					812
					
				

			

		

		

			
				
滚轮经常在选择中用到，主要包括类型选择省市区联动选择年月日联动选择等。项目中的WheelView一般都是组合完成的。但是自定义起来比较复杂，也有一些优秀的第三方库DateSelecter  通过Adapter的思想来灵活解决自定义的问题。但是既然用到了Adapter的思想，那为啥不利用来实现呢？，毕竟我们比较熟悉也方便和项目中现有的Adapter复用。于是我基于对Adapter低侵入性，逻辑单独封装成支持通过Adapter自定义WheelView样式支持横向和竖向支持自定义。

			
		

	





	

		

			

				
					
android 横向滚动选择,简单实现自定义横向滚动选择View

				
			

			

				

					weixin_42301413的博客
				

				

					05-25
					
					1401
					
				

			

		

		

			
				
今日产品经理让在产品里面加了个横向选择的功能，控件样子大致要求为: 网上找了好久没找到此控件，只能自己动手写了，很适合新手练习自定义View，并贡献给大家，效果如下： 其实很多滚轮控件也只是这个简单控件组合一下就可以了 。实现思路这里我偷懒了，没有把上、左、右三个箭头写到控件里面，写进去也简单，不过突然感觉在外面布局，写个方法出来也是蛮帅的。所以今天我们的主角就是中间的可以横向滑动的部分，乍一看就...

			
		

	





	

		

			

				
					
电动车上牌管理系统 SSM毕业设计 附带论文.zip

					
最新发布

				
			

			

				

					11-04
				

			

		

		

			
				
电动车上牌管理系统 SSM毕业设计 附带论文
启动教程:https://www.bilibili.com/video/BV1GK1iYyE2B

			
		

	





	

		

			

				
					
Android仿iOS滚轮选择控件实现与应用

				
			

			

				

					
				

			

		

		

			
				
"Android高仿IOS滚轮选择控件的实现及使用"  在Android开发中，有时为了实现跨平台的一致性或特定设计需求，开发者可能会选择仿照其他操作系统的UI元素，例如iOS的滚轮选择控件（WheelView）。本文将详细介绍如何在...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值