title: Refreshing Custom Listview with holder ClassCastException
body: <p>i`m doing a Custom listview with holder.it is perfectly loaded but while i refresh the data by pull down the application is force closing please help</p>
  
  <pre><code>  @Override
          public View getView(int position, View convertView, ViewGroup parent) {
              // View rowView = convertView;
  
              // String record = (String) getItem(position);
  
              // LayoutInflater inflater = Test_home.this.getLayoutInflater();
  
              LayoutInflater inflater = Test_home.this.getLayoutInflater();
              ViewHolder holder = new ViewHolder();
  
              if (convertView == null) {
                  // LayoutInflater vi = (LayoutInflater)
                  // getSystemService(Context.LAYOUT_INFLATER_SERVICE);
  
                  convertView = inflater.inflate(R.layout.claim_list, null);
  
                  holder = new ViewHolder();
  
                  holder.claim_list_layout = (LinearLayout) convertView
                          .findViewById(R.id.claim_list_layout);
                  holder.claimnumb = (TextView) convertView
                          .findViewById(R.id.claimnumb);
                  holder.insuerdname = (TextView) convertView
                          .findViewById(R.id.insuerdname);
  
                  holder.claimaddress = (TextView) convertView
                          .findViewById(R.id.claimaddress);
                  holder.btn_start = (Button) convertView
                          .findViewById(R.id.btn_start);
  
                  convertView.setTag(holder);
  
              }
              final ViewHolder holder1 = (ViewHolder) convertView.getTag();
              // holder = (ViewHolder) convertView.getTag();
  
              final Claim_list claim_option = claim_list_adaptor.get(position);
  
              holder1.claimnumb.setText(claim_option.getClaimNumber());
              holder1.insuerdname.setText(claim_option.getInsuredName());
              holder1.claimaddress.setText(claim_option.getPropertyAddress());
  
              // Tag Setting
              holder1.claimnumb.setTag(claim_option);
              holder1.insuerdname.setTag(claim_option);
              holder1.claimaddress.setTag(claim_option);
              holder1.claim_list_layout.setTag(claim_option);
              holder1.btn_start.setTag(claim_option);
  
              holder1.btn_start.setVisibility(View.GONE);
              if (position == 0 &amp;&amp; isoncreate) {
                  isoncreate = false;
                  holder1.claim_list_layout
                          .setBackgroundResource(R.drawable.claim_list_active);
                  holder1.btn_start.setVisibility(View.VISIBLE);
                  beanclass.setClaim_info_header("Claim: "
                          + claim_option.getClaimNumber() + " / "
                          + claim_option.getInsuredName());
                  TV_claiminfo.setText(beanclass.getClaim_info_header());
              } else {
                  holder1.claim_list_layout
                          .setBackgroundResource(R.drawable.claim_list_inactive);
              }
  
              return convertView;
          }
  </code></pre>
  
  <p>This is the error </p>
  
  <pre><code>01-02 11:15:39.989: W/dalvikvm(14670): threadid=1: thread exiting with uncaught exception (group=0x409c01f8)
  01-02 11:15:40.062: W/System.err(14670): java.lang.ClassCastException: com.wbpro.da.Claim_list cannot be cast to com.wbpro.flood.Test_home$PullToRefreshListViewSampleAdapter$ViewHolder
  01-02 11:15:40.085: W/System.err(14670):    at com.wbpro.flood.Test_home$PullToRefreshListViewSampleAdapter.getView(Test_home.java:437)
  01-02 11:15:40.085: W/System.err(14670):    at android.widget.HeaderViewListAdapter.getView(HeaderViewListAdapter.java:220)
  </code></pre>
  
  <p>And i`m using the Custom widget for list view</p>
  
  <pre><code> &lt;com.example.pul.PullToRefreshListView
          android:id="@+id/pull_to_refresh_listview"
          android:layout_height="fill_parent"
          android:layout_width="fill_parent"
  
          android:background="@android:color/white"
          android:cacheColorHint="@android:color/white" /&gt;
  </code></pre>
  
  <p>This is the custom class</p>
  
  <p>public class PullToRefreshListView extends ListView {</p>
  
  <pre><code>private static final float PULL_RESISTANCE = 1.7f;
  private static final int BOUNCE_ANIMATION_DURATION = 700;
  private static final int BOUNCE_ANIMATION_DELAY = 100;
  private static final float BOUNCE_OVERSHOOT_TENSION = 1.4f;
  private static final int ROTATE_ARROW_ANIMATION_DURATION = 250;
  
  private static enum State {
      PULL_TO_REFRESH, RELEASE_TO_REFRESH, REFRESHING
  }
  
  /**
   * Interface to implement when you want to get notified of 'pull to refresh'
   * events. Call setOnRefreshListener(..) to activate an OnRefreshListener.
   */
  public interface OnRefreshListener {
  
      /**
       * Method to be called when a refresh is requested
       */
      public void onRefresh();
  }
  
  private static int measuredHeaderHeight;
  
  private boolean scrollbarEnabled;
  private boolean bounceBackHeader;
  private boolean lockScrollWhileRefreshing;
  private boolean showLastUpdatedText;
  private String pullToRefreshText;
  private String releaseToRefreshText;
  private String refreshingText;
  private String lastUpdatedText;
  private SimpleDateFormat lastUpdatedDateFormat = new SimpleDateFormat(
          "dd/MM HH:mm");
  
  private float previousY;
  private int headerPadding;
  private boolean hasResetHeader;
  private long lastUpdated = -1;
  private State state;
  private LinearLayout headerContainer;
  private RelativeLayout header;
  private RotateAnimation flipAnimation;
  private RotateAnimation reverseFlipAnimation;
  private ImageView image;
  private ProgressBar spinner;
  private TextView text;
  private TextView lastUpdatedTextView;
  private OnItemClickListener onItemClickListener;
  private OnItemLongClickListener onItemLongClickListener;
  private OnRefreshListener onRefreshListener;
  
  private float mScrollStartY;
  private final int IDLE_DISTANCE = 5;
  
  public PullToRefreshListView(Context context) {
      super(context);
      init();
  }
  
  public PullToRefreshListView(Context context, AttributeSet attrs) {
      super(context, attrs);
      init();
  }
  
  public PullToRefreshListView(Context context, AttributeSet attrs,
          int defStyle) {
      super(context, attrs, defStyle);
      init();
  }
  
  @Override
  public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
      this.onItemClickListener = onItemClickListener;
  }
  
  @Override
  public void setOnItemLongClickListener(
          OnItemLongClickListener onItemLongClickListener) {
      this.onItemLongClickListener = onItemLongClickListener;
  }
  
  /**
   * Activate an OnRefreshListener to get notified on 'pull to refresh'
   * events.
   * 
   * @param onRefreshListener
   *            The OnRefreshListener to get notified
   */
  public void setOnRefreshListener(OnRefreshListener onRefreshListener) {
      this.onRefreshListener = onRefreshListener;
  }
  
  /**
   * @return If the list is in 'Refreshing' state
   */
  public boolean isRefreshing() {
      return state == State.REFRESHING;
  }
  
  /**
   * Default is false. When lockScrollWhileRefreshing is set to true, the list
   * cannot scroll when in 'refreshing' mode. It's 'locked' on refreshing.
   * 
   * @param lockScrollWhileRefreshing
   */
  public void setLockScrollWhileRefreshing(boolean lockScrollWhileRefreshing) {
      this.lockScrollWhileRefreshing = lockScrollWhileRefreshing;
  }
  
  /**
   * Default is false. Show the last-updated date/time in the 'Pull ro
   * Refresh' header. See 'setLastUpdatedDateFormat' to set the date/time
   * formatting.
   * 
   * @param showLastUpdatedText
   */
  public void setShowLastUpdatedText(boolean showLastUpdatedText) {
      this.showLastUpdatedText = showLastUpdatedText;
      if (!showLastUpdatedText)
          lastUpdatedTextView.setVisibility(View.GONE);
  }
  
  /**
   * Default: "dd/MM HH:mm". Set the format in which the last-updated
   * date/time is shown. Meaningless if 'showLastUpdatedText == false
   * (default)'. See 'setShowLastUpdatedText'.
   * 
   * @param lastUpdatedDateFormat
   */
  public void setLastUpdatedDateFormat(SimpleDateFormat lastUpdatedDateFormat) {
      this.lastUpdatedDateFormat = lastUpdatedDateFormat;
  }
  
  /**
   * Explicitly set the state to refreshing. This is useful when you want to
   * show the spinner and 'Refreshing' text when the refresh was not triggered
   * by 'pull to refresh', for example on start.
   */
  public void setRefreshing() {
      state = State.REFRESHING;
      scrollTo(0, 0);
      setUiRefreshing();
      setHeaderPadding(0);
  }
  
  /**
   * Set the state back to 'pull to refresh'. Call this method when refreshing
   * the data is finished.
   */
  public void onRefreshComplete() {
      state = State.PULL_TO_REFRESH;
      resetHeader();
      lastUpdated = System.currentTimeMillis();
  }
  
  /**
   * Change the label text on state 'Pull to Refresh'
   * 
   * @param pullToRefreshText
   *            Text
   */
  public void setTextPullToRefresh(String pullToRefreshText) {
      this.pullToRefreshText = pullToRefreshText;
      if (state == State.PULL_TO_REFRESH) {
          text.setText(pullToRefreshText);
      }
  }
  
  /**
   * Change the label text on state 'Release to Refresh'
   * 
   * @param releaseToRefreshText
   *            Text
   */
  public void setTextReleaseToRefresh(String releaseToRefreshText) {
      this.releaseToRefreshText = releaseToRefreshText;
      if (state == State.RELEASE_TO_REFRESH) {
          text.setText(releaseToRefreshText);
      }
  }
  
  /**
   * Change the label text on state 'Refreshing'
   * 
   * @param refreshingText
   *            Text
   */
  public void setTextRefreshing(String refreshingText) {
      this.refreshingText = refreshingText;
      if (state == State.REFRESHING) {
          text.setText(refreshingText);
      }
  }
  
  private void init() {
      setVerticalFadingEdgeEnabled(false);
  
      headerContainer = (LinearLayout) LayoutInflater.from(getContext())
              .inflate(R.layout.ptr_header, null);
      header = (RelativeLayout) headerContainer
              .findViewById(R.id.ptr_id_header);
      text = (TextView) header.findViewById(R.id.ptr_id_text);
      lastUpdatedTextView = (TextView) header
              .findViewById(R.id.ptr_id_last_updated);
      image = (ImageView) header.findViewById(R.id.ptr_id_image);
      spinner = (ProgressBar) header.findViewById(R.id.ptr_id_spinner);
  
      pullToRefreshText = getContext()
              .getString(R.string.ptr_pull_to_refresh);
      releaseToRefreshText = getContext().getString(
              R.string.ptr_release_to_refresh);
      refreshingText = getContext().getString(R.string.ptr_refreshing);
      lastUpdatedText = getContext().getString(R.string.ptr_last_updated);
  
      flipAnimation = new RotateAnimation(0, -180,
              RotateAnimation.RELATIVE_TO_SELF, 0.5f,
              RotateAnimation.RELATIVE_TO_SELF, 0.5f);
      flipAnimation.setInterpolator(new LinearInterpolator());
      flipAnimation.setDuration(ROTATE_ARROW_ANIMATION_DURATION);
      flipAnimation.setFillAfter(true);
  
      reverseFlipAnimation = new RotateAnimation(-180, 0,
              RotateAnimation.RELATIVE_TO_SELF, 0.5f,
              RotateAnimation.RELATIVE_TO_SELF, 0.5f);
      reverseFlipAnimation.setInterpolator(new LinearInterpolator());
      reverseFlipAnimation.setDuration(ROTATE_ARROW_ANIMATION_DURATION);
      reverseFlipAnimation.setFillAfter(true);
  
      addHeaderView(headerContainer);
      setState(State.PULL_TO_REFRESH);
      scrollbarEnabled = isVerticalScrollBarEnabled();
  
      ViewTreeObserver vto = header.getViewTreeObserver();
      vto.addOnGlobalLayoutListener(new PTROnGlobalLayoutListener());
  
      super.setOnItemClickListener(new PTROnItemClickListener());
      super.setOnItemLongClickListener(new PTROnItemLongClickListener());
  }
  
  private void setHeaderPadding(int padding) {
      headerPadding = padding;
  
      MarginLayoutParams mlp = (ViewGroup.MarginLayoutParams) header
              .getLayoutParams();
      mlp.setMargins(0, Math.round(padding), 0, 0);
      header.setLayoutParams(mlp);
  }
  
  @Override
  public boolean onTouchEvent(MotionEvent event) {
      if (lockScrollWhileRefreshing
              &amp;&amp; (state == State.REFRESHING || getAnimation() != null
                      &amp;&amp; !getAnimation().hasEnded())) {
          return true;
      }
  
      switch (event.getAction()) {
      case MotionEvent.ACTION_DOWN:
          if (getFirstVisiblePosition() == 0) {
              previousY = event.getY();
          } else {
              previousY = -1;
          }
  
          // Remember where have we started
          mScrollStartY = event.getY();
  
          break;
  
      case MotionEvent.ACTION_UP:
          if (previousY != -1
                  &amp;&amp; (state == State.RELEASE_TO_REFRESH || getFirstVisiblePosition() == 0)) {
              switch (state) {
              case RELEASE_TO_REFRESH:
                  setState(State.REFRESHING);
                  bounceBackHeader();
  
                  break;
  
              case PULL_TO_REFRESH:
                  resetHeader();
                  break;
              }
          }
          break;
  
      case MotionEvent.ACTION_MOVE:
          if (previousY != -1 &amp;&amp; getFirstVisiblePosition() == 0
                  &amp;&amp; Math.abs(mScrollStartY - event.getY()) &gt; IDLE_DISTANCE) {
              float y = event.getY();
              float diff = y - previousY;
              if (diff &gt; 0)
                  diff /= PULL_RESISTANCE;
              previousY = y;
  
              int newHeaderPadding = Math.max(
                      Math.round(headerPadding + diff), -header.getHeight());
  
              if (newHeaderPadding != headerPadding
                      &amp;&amp; state != State.REFRESHING) {
                  setHeaderPadding(newHeaderPadding);
  
                  if (state == State.PULL_TO_REFRESH &amp;&amp; headerPadding &gt; 0) {
                      setState(State.RELEASE_TO_REFRESH);
  
                      image.clearAnimation();
                      image.startAnimation(flipAnimation);
                  } else if (state == State.RELEASE_TO_REFRESH
                          &amp;&amp; headerPadding &lt; 0) {
                      setState(State.PULL_TO_REFRESH);
  
                      image.clearAnimation();
                      image.startAnimation(reverseFlipAnimation);
                  }
              }
          }
  
          break;
      }
  
      return super.onTouchEvent(event);
  }
  
  private void bounceBackHeader() {
      int yTranslate = state == State.REFRESHING ? header.getHeight()
              - headerContainer.getHeight() : -headerContainer.getHeight()
              - headerContainer.getTop() + getPaddingTop();
      ;
  
      TranslateAnimation bounceAnimation = new TranslateAnimation(
              TranslateAnimation.ABSOLUTE, 0, TranslateAnimation.ABSOLUTE, 0,
              TranslateAnimation.ABSOLUTE, 0, TranslateAnimation.ABSOLUTE,
              yTranslate);
  
      bounceAnimation.setDuration(BOUNCE_ANIMATION_DURATION);
      bounceAnimation.setFillEnabled(true);
      bounceAnimation.setFillAfter(false);
      bounceAnimation.setFillBefore(true);
      bounceAnimation.setInterpolator(new OvershootInterpolator(
              BOUNCE_OVERSHOOT_TENSION));
      bounceAnimation.setAnimationListener(new HeaderAnimationListener(
              yTranslate));
  
      startAnimation(bounceAnimation);
  }
  
  private void resetHeader() {
      if (getFirstVisiblePosition() &gt; 0) {
          setHeaderPadding(-header.getHeight());
          setState(State.PULL_TO_REFRESH);
          return;
      }
  
      if (getAnimation() != null &amp;&amp; !getAnimation().hasEnded()) {
          bounceBackHeader = true;
      } else {
          bounceBackHeader();
      }
  }
  
  private void setUiRefreshing() {
      spinner.setVisibility(View.VISIBLE);
      image.clearAnimation();
      image.setVisibility(View.INVISIBLE);
      text.setText(refreshingText);
  }
  
  private void setState(State state) {
      this.state = state;
      switch (state) {
      case PULL_TO_REFRESH:
          spinner.setVisibility(View.INVISIBLE);
          image.setVisibility(View.VISIBLE);
          text.setText(pullToRefreshText);
  
          if (showLastUpdatedText &amp;&amp; lastUpdated != -1) {
              lastUpdatedTextView.setVisibility(View.VISIBLE);
              lastUpdatedTextView.setText(String.format(lastUpdatedText,
                      lastUpdatedDateFormat.format(new Date(lastUpdated))));
          }
  
          break;
  
      case RELEASE_TO_REFRESH:
          spinner.setVisibility(View.INVISIBLE);
          image.setVisibility(View.VISIBLE);
          text.setText(releaseToRefreshText);
          break;
  
      case REFRESHING:
          setUiRefreshing();
  
          lastUpdated = System.currentTimeMillis();
          if (onRefreshListener == null) {
              setState(State.PULL_TO_REFRESH);
          } else {
              onRefreshListener.onRefresh();
          }
  
          break;
      }
  }
  
  @Override
  protected void onScrollChanged(int l, int t, int oldl, int oldt) {
      super.onScrollChanged(l, t, oldl, oldt);
  
      if (!hasResetHeader) {
          if (measuredHeaderHeight &gt; 0 &amp;&amp; state != State.REFRESHING) {
              setHeaderPadding(-measuredHeaderHeight);
          }
  
          hasResetHeader = true;
      }
  }
  
  private class HeaderAnimationListener implements AnimationListener {
  
      private int height, translation;
      private State stateAtAnimationStart;
  
      public HeaderAnimationListener(int translation) {
          this.translation = translation;
      }
  
      @Override
      public void onAnimationStart(Animation animation) {
          stateAtAnimationStart = state;
  
          android.view.ViewGroup.LayoutParams lp = getLayoutParams();
          height = lp.height;
          lp.height = getHeight() - translation;
          setLayoutParams(lp);
  
          if (scrollbarEnabled) {
              setVerticalScrollBarEnabled(false);
          }
      }
  
      @Override
      public void onAnimationEnd(Animation animation) {
          setHeaderPadding(stateAtAnimationStart == State.REFRESHING ? 0
                  : -measuredHeaderHeight - headerContainer.getTop());
          setSelection(0);
  
          android.view.ViewGroup.LayoutParams lp = getLayoutParams();
          lp.height = height;
          setLayoutParams(lp);
  
          if (scrollbarEnabled) {
              setVerticalScrollBarEnabled(true);
          }
  
          if (bounceBackHeader) {
              bounceBackHeader = false;
  
              postDelayed(new Runnable() {
  
                  @Override
                  public void run() {
                      resetHeader();
                  }
              }, BOUNCE_ANIMATION_DELAY);
          } else if (stateAtAnimationStart != State.REFRESHING) {
              setState(State.PULL_TO_REFRESH);
          }
      }
  
      @Override
      public void onAnimationRepeat(Animation animation) {
      }
  }
  
  private class PTROnGlobalLayoutListener implements OnGlobalLayoutListener {
  
      @Override
      public void onGlobalLayout() {
          int initialHeaderHeight = header.getHeight();
  
          if (initialHeaderHeight &gt; 0) {
              measuredHeaderHeight = initialHeaderHeight;
  
              if (measuredHeaderHeight &gt; 0 &amp;&amp; state != State.REFRESHING) {
                  setHeaderPadding(-measuredHeaderHeight);
                  requestLayout();
              }
          }
  
          getViewTreeObserver().removeGlobalOnLayoutListener(this);
      }
  }
  
  private class PTROnItemClickListener implements OnItemClickListener {
  
      @Override
      public void onItemClick(AdapterView&lt;?&gt; adapterView, View view,
              int position, long id) {
          hasResetHeader = false;
  
          if (onItemClickListener != null &amp;&amp; state == State.PULL_TO_REFRESH) {
              // Passing up onItemClick. Correct position with the number of
              // header views
              onItemClickListener.onItemClick(adapterView, view, position
                      - getHeaderViewsCount(), id);
          }
      }
  }
  
  private class PTROnItemLongClickListener implements OnItemLongClickListener {
  
      @Override
      public boolean onItemLongClick(AdapterView&lt;?&gt; adapterView, View view,
              int position, long id) {
          hasResetHeader = false;
  
          if (onItemLongClickListener != null
                  &amp;&amp; state == State.PULL_TO_REFRESH) {
              // Passing up onItemLongClick. Correct position with the number
              // of header views
              return onItemLongClickListener.onItemLongClick(adapterView,
                      view, position - getHeaderViewsCount(), id);
          }
  
          return false;
      }
  }
  </code></pre>
  
  <p>}</p>
  
  <p>i had populated the data fine. but the problem is when is refresh the adaptor.</p>
  
  <pre><code>listView.setOnRefreshListener(new OnRefreshListener() {
  
              @Override
              public void onRefresh() {
                   adapter.loadData();
                  listView.postDelayed(new Runnable() {
  
                      @Override
                      public void run() {
                          listView.onRefreshComplete();
                      }
                  }, 2000);
              }
          });
  
  
  
  ArrayList&lt;Claim_list&gt; claim_list_adaptor = Claim_list.getItems("0", Test_home.this);
  </code></pre>