private void initiateDimens() { 
    mScreenWidth = mContext.getResources().getDisplayMetrics().widthPixels; 
    mJetTopOffset = mParent.getTotalDragDistance() * 0.5f; 
    mTop = -mParent.getTotalDragDistance(); 
  } 

private void createBitmaps() { 
    mLeftClouds = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.clouds_left); 
    mRightClouds = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.clouds_right); 
    mFrontClouds = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.clouds_center); 
    mJet = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.airplane); 
 
    mJetWidthCenter = mJet.getWidth() / 2; 
    mJetHeightCenter = mJet.getHeight() / 2; 
    mFrontCloudWidthCenter = mFrontClouds.getWidth() / 2; 
    mFrontCloudHeightCenter = mFrontClouds.getHeight() / 2; 
 
    mRightCloudsWidthCenter = mRightClouds.getWidth() / 2; 
    mRightCloudsHeightCenter = mRightClouds.getHeight() / 2; 
    mLeftCloudsWidthCenter = mLeftClouds.getWidth() / 2; 
    mLeftCloudsHeightCenter = mLeftClouds.getHeight() / 2; 
  } 

public void draw(@NonNull Canvas canvas) { 
    final int saveCount = canvas.save(); 
 
    // DRAW BACKGROUND. 
    canvas.drawColor(mContext.getResources().getColor(R.color.sky_background)); 
 
    if (isRefreshing) { 
      // Set up new set of wind 
      while (mWinds.size() < WIND_SET_AMOUNT) { 
        float y = (float) (mParent.getTotalDragDistance() / (Math.random() * RANDOM_Y_COEFFICIENT)); 
        float x = random(MIN_WIND_X_OFFSET, MAX_WIND_X_OFFSET); 
 
        // Magic with checking interval between winds 
        if (mWinds.size() > 1) { 
          y = 0; 
          while (y == 0) { 
            float tmp = (float) (mParent.getTotalDragDistance() / (Math.random() * RANDOM_Y_COEFFICIENT)); 
 
            for (Map.Entry<Float, Float> wind : mWinds.entrySet()) { 
              // We want that interval will be greater than fifth part of draggable distance 
              if (Math.abs(wind.getKey() - tmp) > mParent.getTotalDragDistance() / RANDOM_Y_COEFFICIENT) { 
                y = tmp; 
              } else { 
                y = 0; 
                break; 
              } 
            } 
          } 
        } 
 
        mWinds.put(y, x); 
        drawWind(canvas, y, x); 
      } 
 
      // Draw current set of wind 
      if (mWinds.size() >= WIND_SET_AMOUNT) { 
        for (Map.Entry<Float, Float> wind : mWinds.entrySet()) { 
          drawWind(canvas, wind.getKey(), wind.getValue()); 
        } 
      } 
 
      // We should to create new set of winds 
      if (mInverseDirection && mNewWindSet) { 
        mWinds.clear(); 
        mNewWindSet = false; 
        mWindLineWidth = random(MIN_WIND_LINE_WIDTH, MAX_WIND_LINE_WIDTH); 
      } 
 
      // needed for checking direction 
      mLastAnimationTime = mLoadingAnimationTime; 
    } 
 
    drawJet(canvas); 
    drawSideClouds(canvas); 
    drawCenterClouds(canvas); 
 
    canvas.restoreToCount(saveCount); 
  } 

/** 
   * Draw wind on loading animation 
   * 
   * @param canvas - area where we will draw 
   * @param y    - y position fot one of lines 
   * @param xOffset - x offset for on of lines 
   */ 
  private void drawWind(Canvas canvas, float y, float xOffset) { 
    /* We should multiply current animation time with this coefficient for taking all screen width in time 
    Removing slowing of animation with dividing on {@LINK #SLOW_DOWN_ANIMATION_COEFFICIENT} 
    And we should don't forget about distance that should "fly" line that depend on screen of device and x offset 
    */ 
    float cof = (mScreenWidth + xOffset) / (LOADING_ANIMATION_COEFFICIENT / SLOW_DOWN_ANIMATION_COEFFICIENT); 
    float time = mLoadingAnimationTime; 
 
    // HORRIBLE HACK FOR REVERS ANIMATION THAT SHOULD WORK LIKE RESTART ANIMATION 
    if (mLastAnimationTime - mLoadingAnimationTime > 0) { 
      mInverseDirection = true; 
      // take time from 0 to end of animation time 
      time = (LOADING_ANIMATION_COEFFICIENT / SLOW_DOWN_ANIMATION_COEFFICIENT) - mLoadingAnimationTime; 
    } else { 
      mNewWindSet = true; 
      mInverseDirection = false; 
    } 
 
    // Taking current x position of drawing wind 
    // For fully disappearing of line we should subtract wind line width 
    float x = (mScreenWidth - (time * cof)) + xOffset - mWindLineWidth; 
    float xEnd = x + mWindLineWidth; 
 
    canvas.drawLine(x, y, xEnd, y, mWindPaint); 
  } 
 
  private void drawSideClouds(Canvas canvas) { 
    Matrix matrixLeftClouds = mMatrix; 
    Matrix matrixRightClouds = mAdditionalMatrix; 
    matrixLeftClouds.reset(); 
    matrixRightClouds.reset(); 
 
    // Drag percent will newer get more then 1 here 
    float dragPercent = Math.min(1f, Math.abs(mPercent)); 
 
    boolean overdrag = false; 
 
    // But we check here for overdrag 
    if (mPercent > 1.0f) { 
      overdrag = true; 
    } 
 
    float scale; 
    float scalePercentDelta = dragPercent - SCALE_START_PERCENT; 
    if (scalePercentDelta > 0) { 
      float scalePercent = scalePercentDelta / (1.0f - SCALE_START_PERCENT); 
      scale = SIDE_CLOUDS_INITIAL_SCALE + (SIDE_CLOUDS_FINAL_SCALE - SIDE_CLOUDS_INITIAL_SCALE) * scalePercent; 
    } else { 
      scale = SIDE_CLOUDS_INITIAL_SCALE; 
    } 
 
    // Current y position of clouds 
    float dragYOffset = mParent.getTotalDragDistance() * (1.0f - dragPercent); 
 
    // Position where clouds fully visible on screen and we should drag them with content of listView 
    int cloudsVisiblePosition = mParent.getTotalDragDistance() / 2 - mLeftCloudsHeightCenter; 
 
    boolean needMoveCloudsWithContent = false; 
    if (dragYOffset < cloudsVisiblePosition) { 
      needMoveCloudsWithContent = true; 
    } 
 
    float offsetRightX = mScreenWidth - mRightClouds.getWidth(); 
    float offsetRightY = (needMoveCloudsWithContent 
        ? mParent.getTotalDragDistance() * dragPercent - mLeftClouds.getHeight() 
        : dragYOffset) 
        + (overdrag ? mTop : 0); 
 
    float offsetLeftX = 0; 
    float offsetLeftY = (needMoveCloudsWithContent 
        ? mParent.getTotalDragDistance() * dragPercent - mLeftClouds.getHeight() 
        : dragYOffset) 
        + (overdrag ? mTop : 0); 
 
    // Magic with animation on loading process 
    if (isRefreshing) { 
      if (checkCurrentAnimationPart(AnimationPart.FIRST)) { 
        offsetLeftY += getAnimationPartValue(AnimationPart.FIRST) / Y_SIDE_CLOUDS_SLOW_DOWN_COF; 
        offsetRightX -= getAnimationPartValue(AnimationPart.FIRST) / X_SIDE_CLOUDS_SLOW_DOWN_COF; 
      } else if (checkCurrentAnimationPart(AnimationPart.SECOND)) { 
        offsetLeftY += getAnimationPartValue(AnimationPart.SECOND) / Y_SIDE_CLOUDS_SLOW_DOWN_COF; 
        offsetRightX -= getAnimationPartValue(AnimationPart.SECOND) / X_SIDE_CLOUDS_SLOW_DOWN_COF; 
      } else if (checkCurrentAnimationPart(AnimationPart.THIRD)) { 
        offsetLeftY -= getAnimationPartValue(AnimationPart.THIRD) / Y_SIDE_CLOUDS_SLOW_DOWN_COF; 
        offsetRightX += getAnimationPartValue(AnimationPart.THIRD) / X_SIDE_CLOUDS_SLOW_DOWN_COF; 
      } else if (checkCurrentAnimationPart(AnimationPart.FOURTH)) { 
        offsetLeftY -= getAnimationPartValue(AnimationPart.FOURTH) / X_SIDE_CLOUDS_SLOW_DOWN_COF; 
        offsetRightX += getAnimationPartValue(AnimationPart.FOURTH) / Y_SIDE_CLOUDS_SLOW_DOWN_COF; 
      } 
    } 
 
    matrixRightClouds.postScale(scale, scale, mRightCloudsWidthCenter, mRightCloudsHeightCenter); 
    matrixRightClouds.postTranslate(offsetRightX, offsetRightY); 
 
    matrixLeftClouds.postScale(scale, scale, mLeftCloudsWidthCenter, mLeftCloudsHeightCenter); 
    matrixLeftClouds.postTranslate(offsetLeftX, offsetLeftY); 
 
    canvas.drawBitmap(mLeftClouds, matrixLeftClouds, null); 
    canvas.drawBitmap(mRightClouds, matrixRightClouds, null); 
  } 
 
  private void drawCenterClouds(Canvas canvas) { 
    Matrix matrix = mMatrix; 
    matrix.reset(); 
    float dragPercent = Math.min(1f, Math.abs(mPercent)); 
 
    float scale; 
    float overdragPercent = 0; 
    boolean overdrag = false; 
 
    if (mPercent > 1.0f) { 
      overdrag = true; 
      // Here we want know about how mach percent of over drag we done 
      overdragPercent = Math.abs(1.0f - mPercent); 
    } 
 
    float scalePercentDelta = dragPercent - SCALE_START_PERCENT; 
    if (scalePercentDelta > 0) { 
      float scalePercent = scalePercentDelta / (1.0f - SCALE_START_PERCENT); 
      scale = CENTER_CLOUDS_INITIAL_SCALE + (CENTER_CLOUDS_FINAL_SCALE - CENTER_CLOUDS_INITIAL_SCALE) * scalePercent; 
    } else { 
      scale = CENTER_CLOUDS_INITIAL_SCALE; 
    } 
 
    float parallaxPercent = 0; 
    boolean parallax = false; 
    // Current y position of clouds 
    float dragYOffset = mParent.getTotalDragDistance() * dragPercent; 
    // Position when should start parallax scrolling 
    int startParallaxHeight = mParent.getTotalDragDistance() - mFrontCloudHeightCenter; 
 
    if (dragYOffset > startParallaxHeight) { 
      parallax = true; 
      parallaxPercent = dragYOffset - startParallaxHeight; 
    } 
 
    float offsetX = (mScreenWidth / 2) - mFrontCloudWidthCenter; 
    float offsetY = dragYOffset 
        - (parallax ? mFrontCloudHeightCenter + parallaxPercent : mFrontCloudHeightCenter) 
        + (overdrag ? mTop : 0); 
 
    float sx = overdrag ? scale + overdragPercent / 4 : scale; 
    float sy = overdrag ? scale + overdragPercent / 2 : scale; 
 
    if (isRefreshing && !overdrag) { 
      if (checkCurrentAnimationPart(AnimationPart.FIRST)) { 
        sx = scale - (getAnimationPartValue(AnimationPart.FIRST) / LOADING_ANIMATION_COEFFICIENT) / 8; 
      } else if (checkCurrentAnimationPart(AnimationPart.SECOND)) { 
        sx = scale - (getAnimationPartValue(AnimationPart.SECOND) / LOADING_ANIMATION_COEFFICIENT) / 8; 
      } else if (checkCurrentAnimationPart(AnimationPart.THIRD)) { 
        sx = scale + (getAnimationPartValue(AnimationPart.THIRD) / LOADING_ANIMATION_COEFFICIENT) / 6; 
      } else if (checkCurrentAnimationPart(AnimationPart.FOURTH)) { 
        sx = scale + (getAnimationPartValue(AnimationPart.FOURTH) / LOADING_ANIMATION_COEFFICIENT) / 6; 
      } 
      sy = sx; 
    } 
 
    matrix.postScale(sx, sy, mFrontCloudWidthCenter, mFrontCloudHeightCenter); 
    matrix.postTranslate(offsetX, offsetY); 
 
    canvas.drawBitmap(mFrontClouds, matrix, null); 
  } 
 
  private void drawJet(Canvas canvas) { 
    Matrix matrix = mMatrix; 
    matrix.reset(); 
 
    float dragPercent = mPercent; 
    float rotateAngle = 0; 
 
    // Check overdrag 
    if (dragPercent > 1.0f && !mEndOfRefreshing) { 
      rotateAngle = (dragPercent % 1) * 10; 
      dragPercent = 1.0f; 
    } 
 
    float offsetX = ((mScreenWidth * dragPercent) / 2) - mJetWidthCenter; 
 
    float offsetY = mJetTopOffset 
        + (mParent.getTotalDragDistance() / 2) 
        * (1.0f - dragPercent) 
        - mJetHeightCenter; 
 
    if (isRefreshing) { 
      if (checkCurrentAnimationPart(AnimationPart.FIRST)) { 
        offsetY -= getAnimationPartValue(AnimationPart.FIRST); 
      } else if (checkCurrentAnimationPart(AnimationPart.SECOND)) { 
        offsetY -= getAnimationPartValue(AnimationPart.SECOND); 
      } else if (checkCurrentAnimationPart(AnimationPart.THIRD)) { 
        offsetY += getAnimationPartValue(AnimationPart.THIRD); 
      } else if (checkCurrentAnimationPart(AnimationPart.FOURTH)) { 
        offsetY += getAnimationPartValue(AnimationPart.FOURTH); 
      } 
    } 
 
    matrix.setTranslate(offsetX, offsetY); 
 
    if (dragPercent == 1.0f) { 
      matrix.preRotate(rotateAngle, mJetWidthCenter, mJetHeightCenter); 
    } 
 
    canvas.drawBitmap(mJet, matrix, null); 
  } 

private RefreshView mRefreshView; 
<pre name="code" class="java">private ImageView mRefreshImageView; 
<pre name="code" class="java">mRefreshImageView = new ImageView(context); 
    mRefreshView = new RefreshView(getContext(), this); 
    mRefreshImageView.setImageDrawable(mRefreshView); 
 
    addView(mRefreshImageView); 

@Override 
  public boolean onTouchEvent(@NonNull MotionEvent ev) { 
 
    if (!mIsBeingDragged) { 
      return super.onTouchEvent(ev); 
    } 
 
    final int action = MotionEventCompat.getActionMasked(ev); 
 
    switch (action) { 
      case MotionEvent.ACTION_MOVE: { 
        final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId); 
        if (pointerIndex < 0) { 
          return false; 
        } 
 
        final float y = MotionEventCompat.getY(ev, pointerIndex); 
        final float yDiff = y - mInitialMotionY; 
        final float scrollTop = yDiff * DRAG_RATE; 
        mCurrentDragPercent = scrollTop / mTotalDragDistance; 
        if (mCurrentDragPercent < 0) { 
          return false; 
        } 
        float boundedDragPercent = Math.min(1f, Math.abs(mCurrentDragPercent)); 
        float extraOS = Math.abs(scrollTop) - mTotalDragDistance; 
        float slingshotDist = mTotalDragDistance; 
        float tensionSlingshotPercent = Math.max(0, 
            Math.min(extraOS, slingshotDist * 2) / slingshotDist); 
        float tensionPercent = (float) ((tensionSlingshotPercent / 4) - Math.pow( 
            (tensionSlingshotPercent / 4), 2)) * 2f; 
        float extraMove = (slingshotDist) * tensionPercent / 2; 
        int targetY = (int) ((slingshotDist * boundedDragPercent) + extraMove); 
 
        mRefreshView.setPercent(mCurrentDragPercent); 
        setTargetOffsetTop(targetY - mCurrentOffsetTop, true); 
        break; 
      } 
      case MotionEventCompat.ACTION_POINTER_DOWN: 
        final int index = MotionEventCompat.getActionIndex(ev); 
        mActivePointerId = MotionEventCompat.getPointerId(ev, index); 
        break; 
      case MotionEventCompat.ACTION_POINTER_UP: 
        onSecondaryPointerUp(ev); 
        break; 
      case MotionEvent.ACTION_UP: 
      case MotionEvent.ACTION_CANCEL: { 
        if (mActivePointerId == INVALID_POINTER) { 
          return false; 
        } 
        final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId); 
        final float y = MotionEventCompat.getY(ev, pointerIndex); 
        final float overScrollTop = (y - mInitialMotionY) * DRAG_RATE; 
        mIsBeingDragged = false; 
        if (overScrollTop > mTotalDragDistance) { 
          setRefreshing(true, true); 
        } else { 
          mRefreshing = false; 
          animateOffsetToPosition(mAnimateToStartPosition); 
        } 
        mActivePointerId = INVALID_POINTER; 
        return false; 
      } 
    } 
 
    return true; 
  } 

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
  xmlns:tools="http://schemas.android.com/tools" 
  android:layout_width="match_parent" 
  android:layout_height="match_parent" 
  tools:context=".PullToRefreshActivity"> 
 
  <com.hankkin.AnimationPullToRefreshDemo.PullToRefreshView 
    android:id="@+id/pull_to_refresh" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent"> 
 
    <ListView 
      android:id="@+id/list_view" 
      android:divider="@null" 
      android:dividerHeight="0dp" 
      android:fadingEdge="none" 
      android:layout_width="match_parent" 
      android:layout_height="match_parent" /> 
 
  </com.hankkin.AnimationPullToRefreshDemo.PullToRefreshView> 
 
</RelativeLayout> 

Map<String, Integer> map; 
    List<Map<String, Integer>> sampleList = new ArrayList<Map<String, Integer>>(); 
 
 
    int[] colors = { 
        R.color.saffron, 
        R.color.eggplant, 
        R.color.sienna}; 
 
    int[] tripNames = { 
        R.string.trip_to_india, 
        R.string.trip_to_italy, 
        R.string.trip_to_indonesia}; 
 
    for (int i = 0; i < tripNames.length; i++) { 
      map = new HashMap<String, Integer>(); 
      map.put(SampleAdapter.KEY_NAME, tripNames[i]); 
      map.put(SampleAdapter.KEY_COLOR, colors[i]); 
      sampleList.add(map); 
    } 
 
    ListView listView = (ListView) findViewById(R.id.list_view); 
    listView.setAdapter(new SampleAdapter(this, R.layout.list_item, sampleList)); 

mPullToRefreshView = (PullToRefreshView) findViewById(R.id.pull_to_refresh); 
    mPullToRefreshView.setOnRefreshListener(new PullToRefreshView.OnRefreshListener() { 
      @Override 
      public void onRefresh() { 
        mPullToRefreshView.postDelayed(new Runnable() { 
          @Override 
          public void run() { 
            mPullToRefreshView.setRefreshing(false); 
          } 
        }, REFRESH_DELAY); 
      } 
    });