void draw(Canvas canvas) {
    final int width = mBounds.width();
    final int height = mBounds.height();
    final int cx = width / 2;
    final int cy = height / 2;
    boolean drawTriggerWhileFinishing = false;
    int restoreCount = canvas.save();
    canvas.clipRect(mBounds);

    if (mRunning || (mFinishTime > 0)) {
      long now = AnimationUtils.currentAnimationTimeMillis();
      long elapsed = (now - mStartTime) % ANIMATION_DURATION_MS;
      long iterations = (now - mStartTime) / ANIMATION_DURATION_MS;
      float rawProgress = (elapsed / (ANIMATION_DURATION_MS / 100f));

      // If we're not running anymore, that means we're running through
      // the finish animation.
      if (!mRunning) {
        // If the finish animation is done, don't draw anything, and
        // don't repost.
        if ((now - mFinishTime) >= FINISH_ANIMATION_DURATION_MS) {
          mFinishTime = 0;
          return;
        }

        // Otherwise, use a 0 opacity alpha layer to clear the animation
        // from the inside out. This layer will prevent the circles from
        // drawing within its bounds.
        long finishElapsed = (now - mFinishTime) % FINISH_ANIMATION_DURATION_MS;
        float finishProgress = (finishElapsed / (FINISH_ANIMATION_DURATION_MS / 100f));
        float pct = (finishProgress / 100f);
        // Radius of the circle is half of the screen.
        float clearRadius = width / 2 * INTERPOLATOR.getInterpolation(pct);
        mClipRect.set(cx - clearRadius, 0, cx + clearRadius, height);
        canvas.saveLayerAlpha(mClipRect, 0, 0);
        // Only draw the trigger if there is a space in the center of
        // this refreshing view that needs to be filled in by the
        // trigger. If the progress view is just still animating, let it
        // continue animating.
        drawTriggerWhileFinishing = true;
      }

      // First fill in with the last color that would have finished drawing.
      if (iterations == 0) {
        canvas.drawColor(mColor1);
      } else {
        if (rawProgress >= 0 && rawProgress < 25) {
          canvas.drawColor(mColor4);
        } else if (rawProgress >= 25 && rawProgress < 50) {
          canvas.drawColor(mColor1);
        } else if (rawProgress >= 50 && rawProgress < 75) {
          canvas.drawColor(mColor2);
        } else {
          canvas.drawColor(mColor3);
        }
      }

      // Then draw up to 4 overlapping concentric circles of varying radii, based on how far
      // along we are in the cycle.
      // progress 0-50 draw mColor2
      // progress 25-75 draw mColor3
      // progress 50-100 draw mColor4
      // progress 75 (wrap to 25) draw mColor1
      if ((rawProgress >= 0 && rawProgress <= 25)) {
        float pct = (((rawProgress + 25) * 2) / 100f);
        drawCircle(canvas, cx, cy, mColor1, pct);
      }
      if (rawProgress >= 0 && rawProgress <= 50) {
        float pct = ((rawProgress * 2) / 100f);
        drawCircle(canvas, cx, cy, mColor2, pct);
      }
      if (rawProgress >= 25 && rawProgress <= 75) {
        float pct = (((rawProgress - 25) * 2) / 100f);
        drawCircle(canvas, cx, cy, mColor3, pct);
      }
      if (rawProgress >= 50 && rawProgress <= 100) {
        float pct = (((rawProgress - 50) * 2) / 100f);
        drawCircle(canvas, cx, cy, mColor4, pct);
      }
      if ((rawProgress >= 75 && rawProgress <= 100)) {
        float pct = (((rawProgress - 75) * 2) / 100f);
        drawCircle(canvas, cx, cy, mColor1, pct);
      }
      if (mTriggerPercentage > 0 && drawTriggerWhileFinishing) {
        // There is some portion of trigger to draw. Restore the canvas,
        // then draw the trigger. Otherwise, the trigger does not appear
        // until after the bar has finished animating and appears to
        // just jump in at a larger width than expected.
        canvas.restoreToCount(restoreCount);
        restoreCount = canvas.save();
        canvas.clipRect(mBounds);
        drawTrigger(canvas, cx, cy);
      }
      // Keep running until we finish out the last cycle.
      ViewCompat.postInvalidateOnAnimation(
          mParent, mBounds.left, mBounds.top, mBounds.right, mBounds.bottom);
    } else {
      // Otherwise if we're in the middle of a trigger, draw that.
      if (mTriggerPercentage > 0 && mTriggerPercentage <= 1.0) {
        drawTrigger(canvas, cx, cy);
      }
    }
    canvas.restoreToCount(restoreCount);
  }
 void draw(Canvas paramCanvas) {
   int i = this.mBounds.width();
   int i1 = this.mBounds.height();
   int m = i / 2;
   int n = i1 / 2;
   int k = 0;
   int j = paramCanvas.save();
   paramCanvas.clipRect(this.mBounds);
   float f1;
   if ((this.mRunning) || (this.mFinishTime > 0L)) {
     long l1 = AnimationUtils.currentAnimationTimeMillis();
     long l2 = this.mStartTime;
     long l3 = (l1 - this.mStartTime) / 2000L;
     f1 = (float) ((l1 - l2) % 2000L) / 20.0F;
     float f2;
     if (!this.mRunning) {
       if (l1 - this.mFinishTime >= 1000L) {
         this.mFinishTime = 0L;
         return;
       }
       f2 = (float) ((l1 - this.mFinishTime) % 1000L) / 10.0F / 100.0F;
       f2 = i / 2 * INTERPOLATOR.getInterpolation(f2);
       this.mClipRect.set(m - f2, 0.0F, m + f2, i1);
       paramCanvas.saveLayerAlpha(this.mClipRect, 0, 0);
       k = 1;
     }
     if (l3 == 0L) {
       paramCanvas.drawColor(this.mColor1);
       if ((f1 >= 0.0F) && (f1 <= 25.0F)) {
         f2 = (25.0F + f1) * 2.0F / 100.0F;
         drawCircle(paramCanvas, m, n, this.mColor1, f2);
       }
       if ((f1 >= 0.0F) && (f1 <= 50.0F)) {
         f2 = 2.0F * f1 / 100.0F;
         drawCircle(paramCanvas, m, n, this.mColor2, f2);
       }
       if ((f1 >= 25.0F) && (f1 <= 75.0F)) {
         f2 = (f1 - 25.0F) * 2.0F / 100.0F;
         drawCircle(paramCanvas, m, n, this.mColor3, f2);
       }
       if ((f1 >= 50.0F) && (f1 <= 100.0F)) {
         f2 = (f1 - 50.0F) * 2.0F / 100.0F;
         drawCircle(paramCanvas, m, n, this.mColor4, f2);
       }
       if ((f1 >= 75.0F) && (f1 <= 100.0F)) {
         f1 = (f1 - 75.0F) * 2.0F / 100.0F;
         drawCircle(paramCanvas, m, n, this.mColor1, f1);
       }
       i = j;
       if (this.mTriggerPercentage > 0.0F) {
         i = j;
         if (k != 0) {
           paramCanvas.restoreToCount(j);
           i = paramCanvas.save();
           paramCanvas.clipRect(this.mBounds);
           drawTrigger(paramCanvas, m, n);
         }
       }
       ViewCompat.postInvalidateOnAnimation(
           this.mParent,
           this.mBounds.left,
           this.mBounds.top,
           this.mBounds.right,
           this.mBounds.bottom);
     }
   }
   while (true) {
     paramCanvas.restoreToCount(i);
     return;
     if ((f1 >= 0.0F) && (f1 < 25.0F)) {
       paramCanvas.drawColor(this.mColor4);
       break;
     }
     if ((f1 >= 25.0F) && (f1 < 50.0F)) {
       paramCanvas.drawColor(this.mColor1);
       break;
     }
     if ((f1 >= 50.0F) && (f1 < 75.0F)) {
       paramCanvas.drawColor(this.mColor2);
       break;
     }
     paramCanvas.drawColor(this.mColor3);
     break;
     i = j;
     if (this.mTriggerPercentage <= 0.0F) continue;
     i = j;
     if (this.mTriggerPercentage > 1.0D) continue;
     drawTrigger(paramCanvas, m, n);
     i = j;
   }
 }