Android_开发 实用滚轮效果选择数字（十三）

Android_开发 实用滚轮效果选择数字（十三）

 

 

这个滚动的WheelView

 

 /*
  *  Android Wheel Control.
  *  https://code.google.com/p/android-wheel/
  *
  *  Copyright 2010 Yuri Kanivets
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package kankan.wheel.widget;

 import java.util.LinkedList;
 import java.util.List;

 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.GradientDrawable;
 import android.graphics.drawable.GradientDrawable.Orientation;
 import android.os.Handler;
 import android.os.Message;
 import android.text.Layout;
 import android.text.StaticLayout;
 import android.text.TextPaint;
 import android.util.AttributeSet;
 import android.util.FloatMath;
 import android.view.GestureDetector;
 import android.view.GestureDetector.SimpleOnGestureListener;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.animation.Interpolator;
 import android.widget.Scroller;

 import com.shao.pwd.R;

 /**
  * Numeric wheel view.
  *
  * @author Yuri Kanivets
  */
 public class WheelView extends View {
     /** Scrolling duration */
     private static final int SCROLLING_DURATION = 400;

     /** Minimum delta for scrolling */
     private static final int MIN_DELTA_FOR_SCROLLING = 1;

     /** Current value & label text color */
     private static final int VALUE_TEXT_COLOR = 0xF0000000;

     /** Items text color */
     private static final int ITEMS_TEXT_COLOR = 0xFF000000;

     /** Top and bottom shadows colors */
     private static final int[] SHADOWS_COLORS = new int[] { 0xFF111111,
             0x00AAAAAA, 0x00AAAAAA };

     /** Additional items height (is added to standard text item height) */
     private static final int ADDITIONAL_ITEM_HEIGHT = 15;

     /** Text size */
     private static final int TEXT_SIZE = 24;

     /** Top and bottom items offset (to hide that) */
     private static final int ITEM_OFFSET = TEXT_SIZE / 5;

     /** Additional width for items layout */
     private static final int ADDITIONAL_ITEMS_SPACE = 10;

     /** Label offset */
     private static final int LABEL_OFFSET = 8;

     /** Left and right padding value */
     private static final int PADDING = 10;

     /** Default count of visible items */
     private static final int DEF_VISIBLE_ITEMS = 5;

     // Wheel Values
     private WheelAdapter adapter = null;
     private int currentItem = 0;

     // Widths
     private int itemsWidth = 0;
     private int labelWidth = 0;

     // Count of visible items
     private int visibleItems = DEF_VISIBLE_ITEMS;

     // Item height
     private int itemHeight = 0;

     // Text paints
     private TextPaint itemsPaint;
     private TextPaint valuePaint;

     // Layouts
     private StaticLayout itemsLayout;
     private StaticLayout labelLayout;
     private StaticLayout valueLayout;

     // Label & background
     private String label;
     private Drawable centerDrawable;

     // Shadows drawables
     private GradientDrawable topShadow;
     private GradientDrawable bottomShadow;

     // Scrolling
     private boolean isScrollingPerformed;
     private int scrollingOffset;

     // Scrolling animation
     private GestureDetector gestureDetector;
     private Scroller scroller;
     private int lastScrollY;

     // Cyclic
     boolean isCyclic = false;

     // Listeners
     private List<OnWheelChangedListener> changingListeners = new LinkedList<OnWheelChangedListener>();
     private List<OnWheelScrollListener> scrollingListeners = new LinkedList<OnWheelScrollListener>();

     /**
      * Constructor
      */
     public WheelView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         initData(context);
     }

     /**
      * Constructor
      */
     public WheelView(Context context, AttributeSet attrs) {
         super(context, attrs);
         initData(context);
     }

     /**
      * Constructor
      */
     public WheelView(Context context) {
         super(context);
         initData(context);
     }

     /**
      * Initializes class data
      * @param context the context
      */
     private void initData(Context context) {
         gestureDetector = new GestureDetector(context, gestureListener);
         gestureDetector.setIsLongpressEnabled(false);

         scroller = new Scroller(context);
     }

     /**
      * Gets wheel adapter
      * @return the adapter
      */
     public WheelAdapter getAdapter() {
         return adapter;
     }

     /**
      * Sets wheel adapter
      * @param adapter the new wheel adapter
      */
     public void setAdapter(WheelAdapter adapter) {
         this.adapter = adapter;
         invalidateLayouts();
         invalidate();
     }

     /**
      * Set the the specified scrolling interpolator
      * @param interpolator the interpolator
      */
     public void setInterpolator(Interpolator interpolator) {
         scroller.forceFinished(true);
         scroller = new Scroller(getContext(), interpolator);
     }

     /**
      * Gets count of visible items
      *
      * @return the count of visible items
      */
     public int getVisibleItems() {
         return visibleItems;
     }

     /**
      * Sets count of visible items
      *
      * @param count
      *            the new count
      */
     public void setVisibleItems(int count) {
         visibleItems = count;
         invalidate();
     }

     /**
      * Gets label
      *
      * @return the label
      */
     public String getLabel() {
         return label;
     }

     /**
      * Sets label
      *
      * @param newLabel
      *            the label to set
      */
     public void setLabel(String newLabel) {
         if (label == null || !label.equals(newLabel)) {
             label = newLabel;
             labelLayout = null;
             invalidate();
         }
     }

     /**
      * Adds wheel changing listener
      * @param listener the listener
      */
     public void addChangingListener(OnWheelChangedListener listener) {
         changingListeners.add(listener);
     }

     /**
      * Removes wheel changing listener
      * @param listener the listener
      */
     public void removeChangingListener(OnWheelChangedListener listener) {
         changingListeners.remove(listener);
     }

     /**
      * Notifies changing listeners
      * @param oldValue the old wheel value
      * @param newValue the new wheel value
      */
     protected void notifyChangingListeners(int oldValue, int newValue) {
         for (OnWheelChangedListener listener : changingListeners) {
             listener.onChanged(this, oldValue, newValue);
         }
     }

     /**
      * Adds wheel scrolling listener
      * @param listener the listener
      */
     public void addScrollingListener(OnWheelScrollListener listener) {
         scrollingListeners.add(listener);
     }

     /**
      * Removes wheel scrolling listener
      * @param listener the listener
      */
     public void removeScrollingListener(OnWheelScrollListener listener) {
         scrollingListeners.remove(listener);
     }

     /**
      * Notifies listeners about starting scrolling
      */
     protected void notifyScrollingListenersAboutStart() {
         for (OnWheelScrollListener listener : scrollingListeners) {
             listener.onScrollingStarted(this);
         }
     }

     /**
      * Notifies listeners about ending scrolling
      */
     protected void notifyScrollingListenersAboutEnd() {
         for (OnWheelScrollListener listener : scrollingListeners) {
             listener.onScrollingFinished(this);
         }
     }

     /**
      * Gets current value
      *
      * @return the current value
      */
     public int getCurrentItem() {
         return currentItem;
     }

     /**
      * Sets the current item. Does nothing when index is wrong.
      *
      * @param index the item index
      * @param animated the animation flag
      */
     public void setCurrentItem(int index, boolean animated) {
         if (adapter == null || adapter.getItemsCount() == 0) {
             return; // throw?
         }
         if (index < 0 || index >= adapter.getItemsCount()) {
             if (isCyclic) {
                 while (index < 0) {
                     index += adapter.getItemsCount();
                 }
                 index %= adapter.getItemsCount();
             } else{
                 return; // throw?
             }
         }
         if (index != currentItem) {
             if (animated) {
                 scroll(index - currentItem, SCROLLING_DURATION);
             } else {
                 invalidateLayouts();

                 int old = currentItem;
                 currentItem = index;

                 notifyChangingListeners(old, currentItem);

                 invalidate();
             }
         }
     }

     /**
      * Sets the current item w/o animation. Does nothing when index is wrong.
      *
      * @param index the item index
      */
     public void setCurrentItem(int index) {
         setCurrentItem(index, false);
     }

     /**
      * Tests if wheel is cyclic. That means before the 1st item there is shown the last one
      * @return true if wheel is cyclic
      */
     public boolean isCyclic() {
         return isCyclic;
     }

     /**
      * Set wheel cyclic flag
      * @param isCyclic the flag to set
      */
     public void setCyclic(boolean isCyclic) {
         this.isCyclic = isCyclic;

         invalidate();
         invalidateLayouts();
     }

     /**
      * Invalidates layouts
      */
     private void invalidateLayouts() {
         itemsLayout = null;
         valueLayout = null;
         scrollingOffset = 0;
     }

     /**
      * Initializes resources
      */
     private void initResourcesIfNecessary() {
         if (itemsPaint == null) {
             itemsPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG
                     | Paint.FAKE_BOLD_TEXT_FLAG);
             //itemsPaint.density = getResources().getDisplayMetrics().density;
             itemsPaint.setTextSize(TEXT_SIZE);
         }

         if (valuePaint == null) {
             valuePaint = new TextPaint(Paint.ANTI_ALIAS_FLAG
                     | Paint.FAKE_BOLD_TEXT_FLAG | Paint.DITHER_FLAG);
             //valuePaint.density = getResources().getDisplayMetrics().density;
             valuePaint.setTextSize(TEXT_SIZE);
             valuePaint.setShadowLayer(0.1f, 0, 0.1f, 0xFFC0C0C0);
         }

         if (centerDrawable == null) {
             centerDrawable = getContext().getResources().getDrawable(R.drawable.wheel_val);
         }

         if (topShadow == null) {
             topShadow = new GradientDrawable(Orientation.TOP_BOTTOM, SHADOWS_COLORS);
         }

         if (bottomShadow == null) {
             bottomShadow = new GradientDrawable(Orientation.BOTTOM_TOP, SHADOWS_COLORS);
         }

         setBackgroundResource(R.drawable.wheel_bg);
     }

     /**
      * Calculates desired height for layout
      *
      * @param layout
      *            the source layout
      * @return the desired layout height
      */
     private int getDesiredHeight(Layout layout) {
         if (layout == null) {
             return 0;
         }

         int desired = getItemHeight() * visibleItems - ITEM_OFFSET * 2
                 - ADDITIONAL_ITEM_HEIGHT;

         // Check against our minimum height
         desired = Math.max(desired, getSuggestedMinimumHeight());

         return desired;
     }

     /**
      * Returns text item by index
      * @param index the item index
      * @return the item or null
      */
     private String getTextItem(int index) {
         if (adapter == null || adapter.getItemsCount() == 0) {
             return null;
         }
         int count = adapter.getItemsCount();
         if ((index < 0 || index >= count) && !isCyclic) {
             return null;
         } else {
             while (index < 0) {
                 index = count + index;
             }
         }

         index %= count;
         return adapter.getItem(index);
     }

     /**
      * Builds text depending on current value
      *
      * @param useCurrentValue
      * @return the text
      */
     private String buildText(boolean useCurrentValue) {
         StringBuilder itemsText = new StringBuilder();
         int addItems = visibleItems / 2 + 1;

         for (int i = currentItem - addItems; i <= currentItem + addItems; i++) {
             if (useCurrentValue || i != currentItem) {
                 String text = getTextItem(i);
                 if (text != null) {
                     itemsText.append(text);
                 }
             }
             if (i < currentItem + addItems) {
                 itemsText.append("\n");
             }
         }

         return itemsText.toString();
     }

     /**
      * Returns the max item length that can be present
      * @return the max length
      */
     private int getMaxTextLength() {
         WheelAdapter adapter = getAdapter();
         if (adapter == null) {
             return 0;
         }

         int adapterLength = adapter.getMaximumLength();
         if (adapterLength > 0) {
             return adapterLength;
         }

         String maxText = null;
         int addItems = visibleItems / 2;
         for (int i = Math.max(currentItem - addItems, 0);
                 i < Math.min(currentItem + visibleItems, adapter.getItemsCount()); i++) {
             String text = adapter.getItem(i);
             if (text != null && (maxText == null || maxText.length() < text.length())) {
                 maxText = text;
             }
         }

         return maxText != null ? maxText.length() : 0;
     }

     /**
      * Returns height of wheel item
      * @return the item height
      */
     private int getItemHeight() {
         if (itemHeight != 0) {
             return itemHeight;
         } else if (itemsLayout != null && itemsLayout.getLineCount() > 2) {
             itemHeight = itemsLayout.getLineTop(2) - itemsLayout.getLineTop(1);
             return itemHeight;
         }

         return getHeight() / visibleItems;
     }

     /**
      * Calculates control width and creates text layouts
      * @param widthSize the input layout width
      * @param mode the layout mode
      * @return the calculated control width
      */
     private int calculateLayoutWidth(int widthSize, int mode) {
         initResourcesIfNecessary();

         int width = widthSize;

         int maxLength = getMaxTextLength();
         if (maxLength > 0) {
             float textWidth = FloatMath.ceil(Layout.getDesiredWidth("0", itemsPaint));
             itemsWidth = (int) (maxLength * textWidth);
         } else {
             itemsWidth = 0;
         }
         itemsWidth += ADDITIONAL_ITEMS_SPACE; // make it some more

         labelWidth = 0;
         if (label != null && label.length() > 0) {
             labelWidth = (int) FloatMath.ceil(Layout.getDesiredWidth(label, valuePaint));
         }

         boolean recalculate = false;
         if (mode == MeasureSpec.EXACTLY) {
             width = widthSize;
             recalculate = true;
         } else {
             width = itemsWidth + labelWidth + 2 * PADDING;
             if (labelWidth > 0) {
                 width += LABEL_OFFSET;
             }

             // Check against our minimum width
             width = Math.max(width, getSuggestedMinimumWidth());

             if (mode == MeasureSpec.AT_MOST && widthSize < width) {
                 width = widthSize;
                 recalculate = true;
             }
         }

         if (recalculate) {
             // recalculate width
             int pureWidth = width - LABEL_OFFSET - 2 * PADDING;
             if (pureWidth <= 0) {
                 itemsWidth = labelWidth = 0;
             }
             if (labelWidth > 0) {
                 double newWidthItems = (double) itemsWidth * pureWidth
                         / (itemsWidth + labelWidth);
                 itemsWidth = (int) newWidthItems;
                 labelWidth = pureWidth - itemsWidth;
             } else {
                 itemsWidth = pureWidth + LABEL_OFFSET; // no label
             }
         }

         if (itemsWidth > 0) {
             createLayouts(itemsWidth, labelWidth);
         }

         return width;
     }

     /**
      * Creates layouts
      * @param widthItems width of items layout
      * @param widthLabel width of label layout
      */
     private void createLayouts(int widthItems, int widthLabel) {
         if (itemsLayout == null || itemsLayout.getWidth() > widthItems) {
             itemsLayout = new StaticLayout(buildText(isScrollingPerformed), itemsPaint, widthItems,
                     widthLabel > 0 ? Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER,
                     1, ADDITIONAL_ITEM_HEIGHT, false);
         } else {
             itemsLayout.increaseWidthTo(widthItems);
         }

         if (!isScrollingPerformed && (valueLayout == null || valueLayout.getWidth() > widthItems)) {
             String text = getAdapter() != null ? getAdapter().getItem(currentItem) : null;
             valueLayout = new StaticLayout(text != null ? text : "",
                     valuePaint, widthItems, widthLabel > 0 ?
                             Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER,
                             1, ADDITIONAL_ITEM_HEIGHT, false);
         } else if (isScrollingPerformed) {
             valueLayout = null;
         } else {
             valueLayout.increaseWidthTo(widthItems);
         }

         if (widthLabel > 0) {
             if (labelLayout == null || labelLayout.getWidth() > widthLabel) {
                 labelLayout = new StaticLayout(label, valuePaint,
                         widthLabel, Layout.Alignment.ALIGN_NORMAL, 1,
                         ADDITIONAL_ITEM_HEIGHT, false);
             } else {
                 labelLayout.increaseWidthTo(widthLabel);
             }
         }
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         int widthMode = MeasureSpec.getMode(widthMeasureSpec);
         int heightMode = MeasureSpec.getMode(heightMeasureSpec);
         int widthSize = MeasureSpec.getSize(widthMeasureSpec);
         int heightSize = MeasureSpec.getSize(heightMeasureSpec);

         int width = calculateLayoutWidth(widthSize, widthMode);

         int height;
         if (heightMode == MeasureSpec.EXACTLY) {
             height = heightSize;
         } else {
             height = getDesiredHeight(itemsLayout);

             if (heightMode == MeasureSpec.AT_MOST) {
                 height = Math.min(height, heightSize);
             }
         }

         setMeasuredDimension(width, height);
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);

         if (itemsLayout == null) {
             if (itemsWidth == 0) {
                 calculateLayoutWidth(getWidth(), MeasureSpec.EXACTLY);
             } else {
                 createLayouts(itemsWidth, labelWidth);
             }
         }

         if (itemsWidth > 0) {
             canvas.save();
             // Skip padding space and hide a part of top and bottom items
             canvas.translate(PADDING, -ITEM_OFFSET);
             drawItems(canvas);
             drawValue(canvas);
             canvas.restore();
         }

         drawCenterRect(canvas);
         drawShadows(canvas);
     }

     /**
      * Draws shadows on top and bottom of control
      * @param canvas the canvas for drawing
      */
     private void drawShadows(Canvas canvas) {
         topShadow.setBounds(0, 0, getWidth(), getHeight() / visibleItems);
         topShadow.draw(canvas);

         bottomShadow.setBounds(0, getHeight() - getHeight() / visibleItems,
                 getWidth(), getHeight());
         bottomShadow.draw(canvas);
     }

     /**
      * Draws value and label layout
      * @param canvas the canvas for drawing
      */
     private void drawValue(Canvas canvas) {
         valuePaint.setColor(VALUE_TEXT_COLOR);
         valuePaint.drawableState = getDrawableState();

         Rect bounds = new Rect();
         itemsLayout.getLineBounds(visibleItems / 2, bounds);

         // draw label
         if (labelLayout != null) {
             canvas.save();
             canvas.translate(itemsLayout.getWidth() + LABEL_OFFSET, bounds.top);
             labelLayout.draw(canvas);
             canvas.restore();
         }

         // draw current value
         if (valueLayout != null) {
             canvas.save();
             canvas.translate(0, bounds.top + scrollingOffset);
             valueLayout.draw(canvas);
             canvas.restore();
         }
     }

     /**
      * Draws items
      * @param canvas the canvas for drawing
      */
     private void drawItems(Canvas canvas) {
         canvas.save();

         int top = itemsLayout.getLineTop(1);
         canvas.translate(0, - top + scrollingOffset);

         itemsPaint.setColor(ITEMS_TEXT_COLOR);
         itemsPaint.drawableState = getDrawableState();
         itemsLayout.draw(canvas);

         canvas.restore();
     }

     /**
      * Draws rect for current value
      * @param canvas the canvas for drawing
      */
     private void drawCenterRect(Canvas canvas) {
         int center = getHeight() / 2;
         int offset = getItemHeight() / 2;
         centerDrawable.setBounds(0, center - offset, getWidth(), center + offset);
         centerDrawable.draw(canvas);
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         WheelAdapter adapter = getAdapter();
         if (adapter == null) {
             return true;
         }

             if (!gestureDetector.onTouchEvent(event) && event.getAction() == MotionEvent.ACTION_UP) {
             justify();
         }
         return true;
     }

     /**
      * Scrolls the wheel
      * @param delta the scrolling value
      */
     private void doScroll(int delta) {
         scrollingOffset += delta;

         int count = scrollingOffset / getItemHeight();
         int pos = currentItem - count;
         if (isCyclic && adapter.getItemsCount() > 0) {
             // fix position by rotating
             while (pos < 0) {
                 pos += adapter.getItemsCount();
             }
             pos %= adapter.getItemsCount();
         } else if (isScrollingPerformed) {
             //
             if (pos < 0) {
                 count = currentItem;
                 pos = 0;
             } else if (pos >= adapter.getItemsCount()) {
                 count = currentItem - adapter.getItemsCount() + 1;
                 pos = adapter.getItemsCount() - 1;
             }
         } else {
             // fix position
             pos = Math.max(pos, 0);
             pos = Math.min(pos, adapter.getItemsCount() - 1);
         }

         int offset = scrollingOffset;
         if (pos != currentItem) {
             setCurrentItem(pos, false);
         } else {
             invalidate();
         }

         // update offset
         scrollingOffset = offset - count * getItemHeight();
         if (scrollingOffset > getHeight()) {
             scrollingOffset = scrollingOffset % getHeight() + getHeight();
         }
     }

     // gesture listener
     private SimpleOnGestureListener gestureListener = new SimpleOnGestureListener() {
         public boolean onDown(MotionEvent e) {
             if (isScrollingPerformed) {
                 scroller.forceFinished(true);
                 clearMessages();
                 return true;
             }
             return false;
         }

         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
             startScrolling();
             doScroll((int)-distanceY);
             return true;
         }

         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
             lastScrollY = currentItem * getItemHeight() + scrollingOffset;
             int maxY = isCyclic ? 0x7FFFFFFF : adapter.getItemsCount() * getItemHeight();
             int minY = isCyclic ? -maxY : 0;
             scroller.fling(0, lastScrollY, 0, (int) -velocityY / 2, 0, 0, minY, maxY);
             setNextMessage(MESSAGE_SCROLL);
             return true;
         }
     };

     // Messages
     private final int MESSAGE_SCROLL = 0;
     private final int MESSAGE_JUSTIFY = 1;

     /**
      * Set next message to queue. Clears queue before.
      *
      * @param message the message to set
      */
     private void setNextMessage(int message) {
         clearMessages();
         animationHandler.sendEmptyMessage(message);
     }

     /**
      * Clears messages from queue
      */
     private void clearMessages() {
         animationHandler.removeMessages(MESSAGE_SCROLL);
         animationHandler.removeMessages(MESSAGE_JUSTIFY);
     }

     // animation handler
     private Handler animationHandler = new Handler() {
         public void handleMessage(Message msg) {
             scroller.computeScrollOffset();
             int currY = scroller.getCurrY();
             int delta = lastScrollY - currY;
             lastScrollY = currY;
             if (delta != 0) {
                 doScroll(delta);
             }

             // scrolling is not finished when it comes to final Y
             // so, finish it manually
             if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
                 currY = scroller.getFinalY();
                 scroller.forceFinished(true);
             }
             if (!scroller.isFinished()) {
                 animationHandler.sendEmptyMessage(msg.what);
             } else if (msg.what == MESSAGE_SCROLL) {
                 justify();
             } else {
                 finishScrolling();
             }
         }
     };

     /**
      * Justifies wheel
      */
     private void justify() {
         if (adapter == null) {
             return;
         }

         lastScrollY = 0;
         int offset = scrollingOffset;
         int itemHeight = getItemHeight();
         boolean needToIncrease = offset > 0 ? currentItem < adapter.getItemsCount() : currentItem > 0;
         if ((isCyclic || needToIncrease) && Math.abs((float) offset) > (float) itemHeight / 2) {
             if (offset < 0)
                 offset += itemHeight + MIN_DELTA_FOR_SCROLLING;
             else
                 offset -= itemHeight + MIN_DELTA_FOR_SCROLLING;
         }
         if (Math.abs(offset) > MIN_DELTA_FOR_SCROLLING) {
             scroller.startScroll(0, 0, 0, offset, SCROLLING_DURATION);
             setNextMessage(MESSAGE_JUSTIFY);
         } else {
             finishScrolling();
         }
     }

     /**
      * Starts scrolling
      */
     private void startScrolling() {
         if (!isScrollingPerformed) {
             isScrollingPerformed = true;
             notifyScrollingListenersAboutStart();
         }
     }

     /**
      * Finishes scrolling
      */
     void finishScrolling() {
         if (isScrollingPerformed) {
             notifyScrollingListenersAboutEnd();
             isScrollingPerformed = false;
         }
         invalidateLayouts();
         invalidate();
     }


     /**
      * Scroll the wheel
      * @param itemsToSkip items to scroll
      * @param time scrolling duration
      */
     public void scroll(int itemsToScroll, int time) {
         scroller.forceFinished(true);

         lastScrollY = scrollingOffset;
         int offset = itemsToScroll * getItemHeight();

         scroller.startScroll(0, lastScrollY, 0, offset - lastScrollY, time);
         setNextMessage(MESSAGE_SCROLL);

         startScrolling();
     }

 }

 

主布局文件

 

 <?xml version="1.0" encoding="utf-8"?>

 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_height="wrap_content"
     android:orientation="vertical"
     android:background="@drawable/layout_bg"
     android:layout_width="fill_parent">

     <TextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginTop="24dp"
         android:layout_gravity="center_horizontal"
         android:textSize="20sp"
         android:textStyle="bold"
         android:text="Please enter PIN"/>

     <LinearLayout
         android:layout_marginTop="24dp"
         android:layout_gravity="center_horizontal"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content">

         <kankan.wheel.widget.WheelView android:id="@+id/passw_1"
             android:layout_height="wrap_content"
             android:layout_width="wrap_content"/>
         <kankan.wheel.widget.WheelView android:id="@+id/passw_2"
             android:layout_height="wrap_content"
             android:layout_width="wrap_content"/>
         <kankan.wheel.widget.WheelView android:id="@+id/passw_3"
             android:layout_height="wrap_content"
             android:layout_width="wrap_content"/>
         <kankan.wheel.widget.WheelView android:id="@+id/passw_4"
             android:layout_height="wrap_content"
             android:layout_width="wrap_content"/>
         <kankan.wheel.widget.WheelView android:id="@+id/passw_5"
         android:layout_height="wrap_content"
         android:layout_width="wrap_content"/>
         <kankan.wheel.widget.WheelView android:id="@+id/passw_6"
         android:layout_height="wrap_content"
         android:layout_width="wrap_content"/>
     </LinearLayout>

    <TextView android:id="@+id/pwd_status"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginTop="24dp"
         android:layout_gravity="center_horizontal"
         android:textSize="18sp"
         android:textColor="#FFF"
         android:text="Wrong PIN"/>

     <Button android:id="@+id/btn_mix"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_gravity="center_horizontal"
         android:layout_marginTop="12dp"
         android:textSize="18sp"
         android:text="   Mix  "/>

 </LinearLayout>

适配器adapter

 

 

 /*
  *  Copyright 2010 Yuri Kanivets
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package kankan.wheel.widget;

 public interface WheelAdapter {
     /**
      * Gets items count
      * @return the count of wheel items
      */
     public int getItemsCount();

     /**
      * Gets a wheel item by index.
      *
      * @param index the item index
      * @return the wheel item text or null
      */
     public String getItem(int index);

     /**
      * Gets maximum item length. It is used to determine the wheel width.
      * If -1 is returned there will be used the default wheel width.
      *
      * @return the maximum item length or -1
      */
     public int getMaximumLength();
 }

 

 /*
  *  Copyright 2010 Yuri Kanivets
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package kankan.wheel.widget;


 /**
  * Numeric Wheel adapter.
  */
 public class NumericWheelAdapter implements WheelAdapter {

     /** The default min value */
     public static final int DEFAULT_MAX_VALUE = 9;

     /** The default max value */
     private static final int DEFAULT_MIN_VALUE = 0;

     // Values
     private int minValue;
     private int maxValue;

     // format
     private String format;

     /**
      * Default constructor
      */
     public NumericWheelAdapter() {
         this(DEFAULT_MIN_VALUE, DEFAULT_MAX_VALUE);
     }

     /**
      * Constructor
      * @param minValue the wheel min value
      * @param maxValue the wheel max value
      */
     public NumericWheelAdapter(int minValue, int maxValue) {
         this(minValue, maxValue, null);
     }

     /**
      * Constructor
      * @param minValue the wheel min value
      * @param maxValue the wheel max value
      * @param format the format string
      */
     public NumericWheelAdapter(int minValue, int maxValue, String format) {
         this.minValue = minValue;
         this.maxValue = maxValue;
         this.format = format;
     }

     @Override
     public String getItem(int index) {
         if (index >= 0 && index < getItemsCount()) {
             int value = minValue + index;
             return format != null ? String.format(format, value) : Integer.toString(value);
         }
         return null;
     }

     @Override
     public int getItemsCount() {
         return maxValue - minValue + 1;
     }

     @Override
     public int getMaximumLength() {
         int max = Math.max(Math.abs(maxValue), Math.abs(minValue));
         int maxLen = Integer.toString(max).length();
         if (minValue < 0) {
             maxLen++;
         }
         return maxLen;
     }
 }

监听器Listener文件：

 

 /*
  *  Copyright 2010 Yuri Kanivets
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package kankan.wheel.widget;

 /**
  * Wheel scrolled listener interface.
  */
 public interface OnWheelScrollListener {
     /**
      * Callback method to be invoked when scrolling started.
      * @param wheel the wheel view whose state has changed.
      */
     void onScrollingStarted(WheelView wheel);

     /**
      * Callback method to be invoked when scrolling ended.
      * @param wheel the wheel view whose state has changed.
      */
     void onScrollingFinished(WheelView wheel);
 }

 /*
  *  Copyright 2010 Yuri Kanivets
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package kankan.wheel.widget;

 /**
  * Wheel changed listener interface.
  * <p>The currentItemChanged() method is called whenever current wheel positions is changed:
  * <li> New Wheel position is set
  * <li> Wheel view is scrolled
  */
 public interface OnWheelChangedListener {
     /**
      * Callback method to be invoked when current item changed
      * @param wheel the wheel view whose state has changed
      * @param oldValue the old value of current item
      * @param newValue the new value of current item
      */
     void onChanged(WheelView wheel, int oldValue, int newValue);
 }