content: /*
   * Copyright (C) 2013 Sergej Shafarenka, halfbit.de
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file kt 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 com.caesar.PSL_demo.library;
  
  import com.caesar.PSL_demo.BuildConfig;
  import com.caesar.PSL_demo.view.HeadView;
  
  import android.content.Context;
  import android.database.DataSetObserver;
  import android.graphics.Canvas;
  import android.graphics.Color;
  import android.graphics.PointF;
  import android.graphics.Rect;
  import android.graphics.drawable.GradientDrawable;
  import android.graphics.drawable.GradientDrawable.Orientation;
  import android.os.Parcelable;
  import android.util.AttributeSet;
  import android.view.Gravity;
  import android.view.MotionEvent;
  import android.view.SoundEffectConstants;
  import android.view.View;
  import android.view.ViewConfiguration;
  import android.view.accessibility.AccessibilityEvent;
  import android.view.animation.DecelerateInterpolator;
  import android.widget.AbsListView;
  import android.widget.HeaderViewListAdapter;
  import android.widget.ListAdapter;
  import android.widget.ListView;
  import android.widget.ProgressBar;
  import android.widget.Scroller;
  import android.widget.SectionIndexer;
  
  
  /**
   * ListView, which is capable to pin section views at its top while the rest is still scrolled.
   */
  public class PinnedSectionListView extends ListView {
  
      /**添加下拉刷新   -----------start---------------------*/
  
      /** The m last y. */
      private float mLastY = -1;
  
      /** The m scroller. */
      private Scroller mScroller;
  
      /** The m list view listener. */
      private OnRefreshListener mOnRefreshListener;
  
      /** The m header view. */
      private HeadView mHeaderView;
  
      /** The m header view height. */
      private int mHeaderViewHeight;
  
      /** The m enable pull refresh. */
      private boolean mEnablePullRefresh = true;
  
      /** The m pull refreshing. */
      private boolean mPullRefreshing = false;
  
      // for mScroller, scroll back from header or footer.
      /** The m scroll back. */
      private int mScrollBack;
  
      /** The Constant SCROLLBACK_HEADER. */
      private final static int SCROLLBACK_HEADER = 0;
  
      /** The Constant SCROLL_DURATION. */
      private final static int SCROLL_DURATION = 200;
  
      /** The Constant OFFSET_RADIO. */
      private final static float OFFSET_RADIO = 1.8f; // support iOS like pull feature.
  
      /**添加下拉刷新  ------------end------------------*/
  
  
      //-- inner classes
  
  	/** List adapter to be implemented for being used with PinnedSectionListView adapter. */
  	public static interface PinnedSectionListAdapter extends ListAdapter {
  		/** This method shall return 'true' if views of given type has to be pinned. */
  		boolean isItemViewTypePinned(int viewType);
  	}
  
  	/** Wrapper class for pinned section view and its position in the list. */
  	static class PinnedSection {
  		public View view;
  		public int position;
  		public long id;
  	}
  
  	//-- class fields
  
      // fields used for handling touch events
      private final Rect mTouchRect = new Rect();
      private final PointF mTouchPoint = new PointF();
      private int mTouchSlop;
      private View mTouchTarget;
      private MotionEvent mDownEvent;
  
      // fields used for drawing shadow under a pinned section
      private GradientDrawable mShadowDrawable;
      private int mSectionsDistanceY;
      private int mShadowHeight;
  
      /** Delegating listener, can be null. */
      OnScrollListener mDelegateOnScrollListener;
  
      /** Shadow for being recycled, can be null. */
      PinnedSection mRecycleSection;
  
      /** shadow instance with a pinned view, can be null. */
      PinnedSection mPinnedSection;
  
      /** Pinned view Y-translation. We use it to stick pinned view to the next section. */
      int mTranslateY;
  
  	/** Scroll listener which does the magic */
  	private final OnScrollListener mOnScrollListener = new OnScrollListener() {
  
  		@Override public void onScrollStateChanged(AbsListView view, int scrollState) {
  			if (mDelegateOnScrollListener != null) { // delegate
  				mDelegateOnScrollListener.onScrollStateChanged(view, scrollState);
  			}
  		}
  
  		@Override
          public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
  
              if (mDelegateOnScrollListener != null) { // delegate
                  mDelegateOnScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);
              }
  
              // get expected adapter or fail fast
              ListAdapter adapter = getAdapter();
              if (adapter == null || visibleItemCount == 0) return; // nothing to do
  
              final boolean isFirstVisibleItemSection =
                      isItemViewTypePinned(adapter, adapter.getItemViewType(firstVisibleItem));
  
              if (isFirstVisibleItemSection) {
                  View sectionView = getChildAt(0);
                  if (sectionView.getTop() == getPaddingTop()) { // view sticks to the top, no need for pinned shadow
                      destroyPinnedShadow();
                  } else { // section doesn't stick to the top, make sure we have a pinned shadow
                      ensureShadowForPosition(firstVisibleItem, firstVisibleItem, visibleItemCount);
                  }
  
              } else { // section is not at the first visible position
                  int sectionPosition = findCurrentSectionPosition(firstVisibleItem);
                  if (sectionPosition > -1) { // we have section position
                      ensureShadowForPosition(sectionPosition, firstVisibleItem, visibleItemCount);
                  } else { // there is no section for the first visible item, destroy shadow
                      destroyPinnedShadow();
                  }
              }
  		};
  
  	};
  
  	/** Default change observer. */
      private final DataSetObserver mDataSetObserver = new DataSetObserver() {
          @Override public void onChanged() {
              recreatePinnedShadow();
          };
          @Override public void onInvalidated() {
              recreatePinnedShadow();
          }
      };
  
  	//-- constructors
  
      public PinnedSectionListView(Context context, AttributeSet attrs) {
          super(context, attrs);
          initView();
          initWithContext(context);
      }
  
      public PinnedSectionListView(Context context, AttributeSet attrs, int defStyle) {
          super(context, attrs, defStyle);
          initView();
          initWithContext(context);
      }
  
      private void initView() {
          setOnScrollListener(mOnScrollListener);
          mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
          initShadow(true);
      }
  
      /** 初始化下拉刷新上下文
       * @param context
       */
      private void initWithContext(Context context) {
  
          mScroller = new Scroller(context, new DecelerateInterpolator());
  
          super.setOnScrollListener(mOnScrollListener);
  
          // init header view
          mHeaderView = new HeadView(context);
  
          // init header height
          mHeaderViewHeight = mHeaderView.getHeaderHeight();
          mHeaderView.setGravity(Gravity.BOTTOM);
          addHeaderView(mHeaderView);
          // 默认是可以下拉刷新
          setPullRefreshEnable(true);
      }
  
      //-- public API methods
  
      public void setShadowVisible(boolean visible) {
          initShadow(visible);
          if (mPinnedSection != null) {
              View v = mPinnedSection.view;
              invalidate(v.getLeft(), v.getTop(), v.getRight(), v.getBottom() + mShadowHeight);
          }
      }
  
      //-- pinned section drawing methods
  
      public void initShadow(boolean visible) {
          if (visible) {
              if (mShadowDrawable == null) {
                  mShadowDrawable = new GradientDrawable(Orientation.TOP_BOTTOM,
                          new int[] { Color.parseColor("#ffa0a0a0"), Color.parseColor("#50a0a0a0"), Color.parseColor("#00a0a0a0")});
                  mShadowHeight = (int) (8 * getResources().getDisplayMetrics().density);
              }
          } else {
              if (mShadowDrawable != null) {
                  mShadowDrawable = null;
                  mShadowHeight = 0;
              }
          }
      }
  
  	/** Create shadow wrapper with a pinned view for a view at given position */
  	void createPinnedShadow(int position) {
  
  		// try to recycle shadow
  		PinnedSection pinnedShadow = mRecycleSection;
  		mRecycleSection = null;
  
  		// create new shadow, if needed
  		if (pinnedShadow == null) pinnedShadow = new PinnedSection();
  		// request new view using recycled view, if such
  		View pinnedView = getAdapter().getView(position, pinnedShadow.view, PinnedSectionListView.this);
  
  		// read layout parameters
  		LayoutParams layoutParams = (LayoutParams) pinnedView.getLayoutParams();
  		if (layoutParams == null) { // create default layout params
  		    layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
  		}
  
  		int heightMode = MeasureSpec.getMode(layoutParams.height);
  		int heightSize = MeasureSpec.getSize(layoutParams.height);
  
  		if (heightMode == MeasureSpec.UNSPECIFIED) heightMode = MeasureSpec.EXACTLY;
  
  		int maxHeight = getHeight() - getListPaddingTop() - getListPaddingBottom();
  		if (heightSize > maxHeight) heightSize = maxHeight;
  
  		// measure & layout
  		int ws = MeasureSpec.makeMeasureSpec(getWidth() - getListPaddingLeft() - getListPaddingRight(), MeasureSpec.EXACTLY);
  		int hs = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
  		pinnedView.measure(ws, hs);
  		pinnedView.layout(0, 0, pinnedView.getMeasuredWidth(), pinnedView.getMeasuredHeight());
  		mTranslateY = 0;
  
  		// initialize pinned shadow
  		pinnedShadow.view = pinnedView;
  		pinnedShadow.position = position;
  		pinnedShadow.id = getAdapter().getItemId(position);
  
  		// store pinned shadow
  		mPinnedSection = pinnedShadow;
  	}
  
  	/** Destroy shadow wrapper for currently pinned view */
  	void destroyPinnedShadow() {
  	    if (mPinnedSection != null) {
  	        // keep shadow for being recycled later
  	        mRecycleSection = mPinnedSection;
  	        mPinnedSection = null;
  	    }
  	}
  
  	/** Makes sure we have an actual pinned shadow for given position. */
      void ensureShadowForPosition(int sectionPosition, int firstVisibleItem, int visibleItemCount) {
          if (visibleItemCount < 2) { // no need for creating shadow at all, we have a single visible item
              destroyPinnedShadow();
              return;
          }
  
          if (mPinnedSection != null
                  && mPinnedSection.position != sectionPosition) { // invalidate shadow, if required
              destroyPinnedShadow();
          }
  
          if (mPinnedSection == null) { // create shadow, if empty
              createPinnedShadow(sectionPosition);
          }
  
          // align shadow according to next section position, if needed
          int nextPosition = sectionPosition + 1;
          if (nextPosition < getCount()) {
              int nextSectionPosition = findFirstVisibleSectionPosition(nextPosition,
                      visibleItemCount - (nextPosition - firstVisibleItem));
              if (nextSectionPosition > -1) {
                  View nextSectionView = getChildAt(nextSectionPosition - firstVisibleItem);
                  final int bottom = mPinnedSection.view.getBottom() + getPaddingTop();
                  mSectionsDistanceY = nextSectionView.getTop() - bottom;
                  if (mSectionsDistanceY < 0) {
                      // next section overlaps pinned shadow, move it up
                      mTranslateY = mSectionsDistanceY;
                  } else {
                      // next section does not overlap with pinned, stick to top
                      mTranslateY = 0;
                  }
              } else {
                  // no other sections are visible, stick to top
                  mTranslateY = 0;
                  mSectionsDistanceY = Integer.MAX_VALUE;
              }
          }
  
      }
  
  	int findFirstVisibleSectionPosition(int firstVisibleItem, int visibleItemCount) {
  		ListAdapter adapter = getAdapter();
  		for (int childIndex = 0; childIndex < visibleItemCount; childIndex++) {
  			int position = firstVisibleItem + childIndex;
  			int viewType = adapter.getItemViewType(position);
  			if (isItemViewTypePinned(adapter, viewType)) return position;
  		}
  		return -1;
  	}
  
  	int findCurrentSectionPosition(int fromPosition) {
  		ListAdapter adapter = getAdapter();
  
  		if (adapter instanceof SectionIndexer) {
  			// try fast way by asking section indexer
  			SectionIndexer indexer = (SectionIndexer) adapter;
  			int sectionPosition = indexer.getSectionForPosition(fromPosition);
  			int itemPosition = indexer.getPositionForSection(sectionPosition);
  			int typeView = adapter.getItemViewType(itemPosition);
  			if (isItemViewTypePinned(adapter, typeView)) {
  				return itemPosition;
  			} // else, no luck
  		}
  
  		// try slow way by looking through to the next section item above
  		for (int position=fromPosition; position>=0; position--) {
  			int viewType = adapter.getItemViewType(position);
  			if (isItemViewTypePinned(adapter, viewType)) return position;
  		}
  		return -1; // no candidate found
  	}
  
  	void recreatePinnedShadow() {
  	    destroyPinnedShadow();
          ListAdapter adapter = getAdapter();
          if (adapter != null && adapter.getCount() > 0) {
              int firstVisiblePosition = getFirstVisiblePosition();
              int sectionPosition = findCurrentSectionPosition(firstVisiblePosition);
              if (sectionPosition == -1) return; // no views to pin, exit
              ensureShadowForPosition(sectionPosition,
                      firstVisiblePosition, getLastVisiblePosition() - firstVisiblePosition);
          }
  	}
  
  	@Override
  	public void setOnScrollListener(OnScrollListener listener) {
  		if (listener == mOnScrollListener) {
  			super.setOnScrollListener(listener);
  		} else {
  			mDelegateOnScrollListener = listener;
  		}
  	}
  
  	@Override
  	public void onRestoreInstanceState(Parcelable state) {
  		super.onRestoreInstanceState(state);
  		post(new Runnable() {
  			@Override public void run() { // restore pinned view after configuration change
  			    recreatePinnedShadow();
  			}
  		});
  	}
  
  	@Override
  	public void setAdapter(ListAdapter adapter) {
  
  	    // assert adapter in debug mode
  		if (BuildConfig.DEBUG && adapter != null) {
  			if (!(adapter instanceof PinnedSectionListAdapter))
  				throw new IllegalArgumentException("Does your adapter implement PinnedSectionListAdapter?");
  			if (adapter.getViewTypeCount() < 2)
  				throw new IllegalArgumentException("Does your adapter handle at least two types" +
  						" of views in getViewTypeCount() method: items and sections?");
  		}
  
  		// unregister observer at old adapter and register on new one
  		ListAdapter oldAdapter = getAdapter();
  		if (oldAdapter != null) oldAdapter.unregisterDataSetObserver(mDataSetObserver);
  		if (adapter != null) adapter.registerDataSetObserver(mDataSetObserver);
  
  		// destroy pinned shadow, if new adapter is not same as old one
  		if (oldAdapter != adapter) destroyPinnedShadow();
  
  		super.setAdapter(adapter);
  	}
  
  	@Override
  	protected void onLayout(boolean changed, int l, int t, int r, int b) {
  	    super.onLayout(changed, l, t, r, b);
          if (mPinnedSection != null) {
              int parentWidth = r - l - getPaddingLeft() - getPaddingRight();
              int shadowWidth = mPinnedSection.view.getWidth();
              if (parentWidth != shadowWidth) {
                  recreatePinnedShadow();
              }
          }
  	}
  
  	@Override
  	protected void dispatchDraw(Canvas canvas) {
  		super.dispatchDraw(canvas);
  
  		if (mPinnedSection != null) {
  
  			// prepare variables
  			int pLeft = getListPaddingLeft();
  			int pTop = getListPaddingTop();
  			View view = mPinnedSection.view;
  
  			// draw child
  			canvas.save();
  
  			int clipHeight = view.getHeight() +
  			        (mShadowDrawable == null ? 0 : Math.min(mShadowHeight, mSectionsDistanceY));
  			canvas.clipRect(pLeft, pTop, pLeft + view.getWidth(), pTop + clipHeight);
  
  			canvas.translate(pLeft, pTop + mTranslateY);
  			drawChild(canvas, mPinnedSection.view, getDrawingTime());
  
  			if (mShadowDrawable != null && mSectionsDistanceY > 0) {
  			    mShadowDrawable.setBounds(mPinnedSection.view.getLeft(),
  			            mPinnedSection.view.getBottom(),
  			            mPinnedSection.view.getRight(),
  			            mPinnedSection.view.getBottom() + mShadowHeight);
  			    mShadowDrawable.draw(canvas);
  			}
  
  			canvas.restore();
  		}
  	}
  
  	//-- touch handling methods
  
      @Override
      public boolean dispatchTouchEvent(MotionEvent ev) {
  
          final float x = ev.getX();
          final float y = ev.getY();
          final int action = ev.getAction();
  
          if (action == MotionEvent.ACTION_DOWN
                  && mTouchTarget == null
                  && mPinnedSection != null
                  && isPinnedViewTouched(mPinnedSection.view, x, y)) { // create touch target
  
              // user touched pinned view
              mTouchTarget = mPinnedSection.view;
              mTouchPoint.x = x;
              mTouchPoint.y = y;
  
              // copy down event for eventually be used later
              mDownEvent = MotionEvent.obtain(ev);
          }
  
          if (mTouchTarget != null) {
              if (isPinnedViewTouched(mTouchTarget, x, y)) { // forward event to pinned view
                  mTouchTarget.dispatchTouchEvent(ev);
              }
  
              if (action == MotionEvent.ACTION_UP) { // perform onClick on pinned view
                  super.dispatchTouchEvent(ev);
                  performPinnedItemClick();
                  clearTouchTarget();
  
              } else if (action == MotionEvent.ACTION_CANCEL) { // cancel
                  clearTouchTarget();
  
              } else if (action == MotionEvent.ACTION_MOVE) {
                  if (Math.abs(y - mTouchPoint.y) > mTouchSlop) {
  
                      // cancel sequence on touch target
                      MotionEvent event = MotionEvent.obtain(ev);
                      event.setAction(MotionEvent.ACTION_CANCEL);
                      mTouchTarget.dispatchTouchEvent(event);
                      event.recycle();
  
                      // provide correct sequence to super class for further handling
                      super.dispatchTouchEvent(mDownEvent);
                      super.dispatchTouchEvent(ev);
                      clearTouchTarget();
  
                  }
              }
  
              return true;
          }
  
          // call super if this was not our pinned view
          return super.dispatchTouchEvent(ev);
      }
  
      private boolean isPinnedViewTouched(View view, float x, float y) {
          view.getHitRect(mTouchRect);
  
          // by taping top or bottom padding, the list performs on click on a border item.
          // we don't add top padding here to keep behavior consistent.
          mTouchRect.top += mTranslateY;
  
          mTouchRect.bottom += mTranslateY + getPaddingTop();
          mTouchRect.left += getPaddingLeft();
          mTouchRect.right -= getPaddingRight();
          return mTouchRect.contains((int)x, (int)y);
      }
  
      private void clearTouchTarget() {
          mTouchTarget = null;
          if (mDownEvent != null) {
              mDownEvent.recycle();
              mDownEvent = null;
          }
      }
  
      private boolean performPinnedItemClick() {
          if (mPinnedSection == null) return false;
  
          OnItemClickListener listener = getOnItemClickListener();
          if (listener != null) {
              View view =  mPinnedSection.view;
              playSoundEffect(SoundEffectConstants.CLICK);
              if (view != null) {
                  view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
              }
              listener.onItemClick(this, view, mPinnedSection.position, mPinnedSection.id);
              return true;
          }
          return false;
      }
  
      public static boolean isItemViewTypePinned(ListAdapter adapter, int viewType) {
          if (adapter instanceof HeaderViewListAdapter) {
              adapter = ((HeaderViewListAdapter)adapter).getWrappedAdapter();
          }
          return ((PinnedSectionListAdapter) adapter).isItemViewTypePinned(viewType);
      }
  
  
      //下拉刷新添加方法----------------------------start-----------------------------
  
      /** 打开下拉刷新开关
       * @param enable  true可以  false不能
       */
      public void setPullRefreshEnable(boolean enable) {
          mEnablePullRefresh = enable;
          if (!mEnablePullRefresh) {
              mHeaderView.setVisibility(View.INVISIBLE);
          } else {
              mHeaderView.setVisibility(View.VISIBLE);
          }
      }
  
      /**
       * 停止刷新，重置headerView
       */
      public void stopRefresh() {
          if (mPullRefreshing == true) {
              mPullRefreshing = false;
              resetHeaderHeight();
          }
      }
  
      /**
       * 重置headerView 高度
       */
      private void resetHeaderHeight() {
          //当前下拉到的高度
          int height = mHeaderView.getVisiableHeight();
          if (height < mHeaderViewHeight || !mPullRefreshing) {
              //距离短  隐藏
              mScrollBack = SCROLLBACK_HEADER;
              mScroller.startScroll(0, height, 0, -1*height, SCROLL_DURATION);
          }else if(height > mHeaderViewHeight || !mPullRefreshing){
              //距离多的  弹回到mHeaderViewHeight
              mScrollBack = SCROLLBACK_HEADER;
              mScroller.startScroll(0, height, 0, -(height-mHeaderViewHeight), SCROLL_DURATION);
          }
  
          invalidate();
      }
  
      /** 更新headerView 高度
       * @param delta
       */
      private void updateHeaderHeight(float delta) {
          int newHeight = (int) delta + mHeaderView.getVisiableHeight();
          mHeaderView.setVisiableHeight(newHeight);
          if (mEnablePullRefresh && !mPullRefreshing) {
              if (mHeaderView.getVisiableHeight() >= mHeaderViewHeight) {
                  mHeaderView.setState(HeadView.STATE_READY);
              } else {
                  mHeaderView.setState(HeadView.STATE_NORMAL);
              }
          }
          setSelection(0);
      }
  
      @Override
      public boolean onTouchEvent(MotionEvent ev) {
          if (mLastY == -1) {
              mLastY = ev.getRawY();
          }
  
          switch (ev.getAction()) {
              case MotionEvent.ACTION_DOWN:
                  mLastY = ev.getRawY();
                  break;
              case MotionEvent.ACTION_MOVE:
                  final float deltaY = ev.getRawY() - mLastY;
                  mLastY = ev.getRawY();
                  //下拉滑动
                  if (mEnablePullRefresh && getFirstVisiblePosition() == 0 && (mHeaderView.getVisiableHeight() > 0 || deltaY > 0)) {
                      updateHeaderHeight(deltaY / OFFSET_RADIO);
                  }
                  break;
              case MotionEvent.ACTION_UP:
                  mLastY = -1;
                  if (getFirstVisiblePosition() == 0) {
                      //需要刷新的条件
                      if (mEnablePullRefresh && mHeaderView.getVisiableHeight() >= mHeaderViewHeight) {
                          mPullRefreshing = true;
                          mHeaderView.setState(HeadView.STATE_REFRESHING);
                          if (mOnRefreshListener != null) {
                              //刷新
                              mOnRefreshListener.OnRefresh();
                          }
                      }
  
                      if(mEnablePullRefresh){
                          //弹回
                          resetHeaderHeight();
                      }
                      //在到底部就加载下一页
                  }
                  break;
              default:
                  break;
          }
          return super.onTouchEvent(ev);
      }
  
  
      @Override
      public void computeScroll() {
          if (mScroller.computeScrollOffset()) {
              if (mScrollBack == SCROLLBACK_HEADER) {
                  mHeaderView.setVisiableHeight(mScroller.getCurrY());
              }
              postInvalidate();
          }
          super.computeScroll();
      }
  
  
      /**
       *  添加下拉刷新监听接口
       *
       * @param
       */
      public void setOnRefreshListener(OnRefreshListener onRefreshListener) {
          mOnRefreshListener = onRefreshListener;
      }
  
  
      /** 获得头部view
       * @return
       */
      public HeadView getHeaderView() {
          return mHeaderView;
      }
  
      /** 获得头部progressBar 用于自定义样式
       * @return
       */
      public ProgressBar getHeaderProgressBar() {
          return mHeaderView.getHeaderProgressBar();
      }
  
      /**
       * 下拉刷新接口
       *
       */
      public interface OnRefreshListener{
          void OnRefresh();
      }
  
  }
  