Android PinnedSectionListView异常崩溃报错

布满荆棘的人生 2024-02-17 16:31 16阅读 0赞

**Android PinnedSectionListView异常崩溃报错：java.lang.ClassCastException: android.view.ViewGroup$LayoutParams cannot be cast to android.widget.AbsListView$LayoutParams**

Android PinnedSectionListView是一个良好的第三方开源悬停分组ListView，其在github上的项目主页是：https://github.com/beworker/pinned-section-listview ，在涉及到一些联系人分组，好友分组等需要对ListView进行分组的情况下，使用起来效果不错。  
但是作为开源项目，本身也在不停的迭代和完善中，最近（截止2015年11月26日）发现PinnedSectionListView在一些Android SDK版本中运行时候异常崩溃报错，如图：  
![Center][]  
  
  
报错的关键内容是：

java.lang.ClassCastException: android.view.ViewGroup$LayoutParams cannot be cast to android.widget.AbsListView$LayoutParams

错误内容提示在PinnedSectionListView.java的202行出现错误，这是PinnedSectionListView.java源代码中的原始内容：

// read layout parameters
    		LayoutParams layoutParams = (LayoutParams) pinnedView.getLayoutParams();
    		if (layoutParams == null) {
    		    layoutParams = (LayoutParams) generateDefaultLayoutParams();
    		    pinnedView.setLayoutParams(layoutParams);
    		}

如图：

![Center 1][]

经由研究发现，此原因是在调用Android系统的generateDefaultLayoutParams()方法时候，发生异常，致使代码运行获得的结果layoutParams不正常，进而导致PinnedSectionListView崩溃。

解决方案：  
自己动手重写Android系统的generateDefaultLayoutParams()方法，返回自己定制的LayoutParams值。  
  
具体实现：  
在PinnedSectionListView.java中增加自己重写的generateDefaultLayoutParams()方法：

//add by Zhang Phil @CSDN
        @Override
        protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
        	
        	LayoutParams mLayoutParams=new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
        	
        	return mLayoutParams;
        }

最终修复bug，改进后的PinnedSectionListView.java全部源代码为：

/*
     * 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.hb.views;
    
    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.MotionEvent;
    import android.view.SoundEffectConstants;
    import android.view.View;
    import android.view.ViewConfiguration;
    import android.view.ViewGroup;
    import android.view.accessibility.AccessibilityEvent;
    import android.widget.AbsListView;
    import android.widget.HeaderViewListAdapter;
    import android.widget.ListAdapter;
    import android.widget.ListView;
    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 {
    
        //-- 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();
        }
    
        public PinnedSectionListView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            initView();
        }
    
        private void initView() {
            setOnScrollListener(mOnScrollListener);
            mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
            initShadow(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;
                }
            }
        }
    
        //add by Zhang Phil @CSDN
        @Override
        protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
        	
        	LayoutParams mLayoutParams=new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
        	
        	return mLayoutParams;
        }
        
    	/** 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) {
    		    layoutParams = (LayoutParams) generateDefaultLayoutParams();
    		    pinnedView.setLayoutParams(layoutParams);
    		}
    
    		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();
    
            int adapterDataCount = adapter.getCount();
            if (getLastVisiblePosition() >= adapterDataCount) return -1; // dataset has changed, no candidate
    
            if (firstVisibleItem+visibleItemCount >= adapterDataCount){//added to prevent index Outofbound (in case)
                visibleItemCount = adapterDataCount-firstVisibleItem;
            }
    
    		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 (fromPosition >= adapter.getCount()) return -1; // dataset has changed, no candidate
    		
    		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 && getAdapter().isEnabled(mPinnedSection.position)) {
                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);
        }
    
    }

这样PinnedSectionListView.java就可以正常使用了。  
  
  
附录我写的参考文章：  
【文章1】《类似通讯录分组的Android PinnedSectionListView，且分组标签悬停滑入滑出》链接地址：http://blog.csdn.net/zhangphil/article/details/47144125  
【文章2】《Android基于PinnedSectionListView实现联系人通讯录》链接地址：http://blog.csdn.net/zhangphil/article/details/47271741

[Center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/54ec18c3b23e49339d01371f6f4d2629.png
[Center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/0f587774b32146d38c2d335de303cd2a.png