             scrollView.addObserver(self, forKeyPath: ObserverOffsetKeyPath, options: .New, context: &RefresherContext)
             targetView = scrollView
         }
-    }
-    
-    private func setupIndicator() {
-        indicator.lineWidth = 2
-        indicator.lotateDuration = 1
-        indicator.strokeDuration = 0.5
-        indicator.center = center
-        indicator.autoresizingMask = .FlexibleLeftMargin | .FlexibleRightMargin | .FlexibleTopMargin | .FlexibleBottomMargin
-        addSubview(indicator)
     }
     
     private func refreshStart(scrollView: UIScrollView) {

            return initialInsetTop + (refreshing ? bounds.height : 0)
        }
        
        public convenience init() {
            self.init(frame: CGRect.zeroRect)
        }

    }
}

// MARK: - Animation
public extension SpringIndicator {
    public func startAnimation(expand: Bool = false) {
        stopAnimationsHandler = nil
        
        if isSpinning() {
            return
        }
        
        indicatorView.layer.addAnimation(lotateAnimation(), forKey: Me.LotateAnimationKey)
        
        nextAnimation(expand)
        
        let timer: NSTimer
        if expand {
            timer = createTimer(timeInterval: strokeDuration, userInfo: Me.ContractAnimationKey, repeats: false)
        } else {
            timer = createTimer(timeInterval: strokeDuration * 2, userInfo: Me.GroupAnimationKey, repeats: true)
        }
        
        setStrokeTimer(timer)
    }
    
    public func stopAnimation(waitAnimation: Bool, completion: ((SpringIndicator) -> Void)? = nil) {
        if waitAnimation {
            stopAnimationsHandler = { indicator in
                indicator.stopAnimation(false, completion: completion)
            }
        } else {
            strokeTimer?.invalidate()
            strokeTimer = nil
            
            stopAnimationsHandler = nil
            indicatorView.layer.removeAllAnimations()
            pathLayer?.removeAllAnimations()
            pathLayer = nil
            
            if NSThread.currentThread().isMainThread {
                completion?(self)
            } else {
                dispatch_async(dispatch_get_main_queue()) {
                    completion?(self)
                }
            }
        }
    }
    
    private func nextAnimation(expand: Bool) {
        var count: Double = 0
        if expand == false {
            count = incrementAnimationCount()
        }
        
        let shapeLayer = rotateLayer(count)
        pathLayer = shapeLayer
        indicatorView.layer.addSublayer(shapeLayer)
        
        nextTransaction(expand)
    }
    
    private func nextTransaction(expand: Bool) {
        if expand {
            pathLayer?.addAnimation(contractAnimation(), forKey: Me.ContractAnimationKey)
        } else {
            pathLayer?.addAnimation(groupAnimation(), forKey: Me.GroupAnimationKey)
        }
    }
    
    private func lotateAnimation() -> CAPropertyAnimation {
        let anim = CABasicAnimation(keyPath: "transform.rotation.z")
        anim.duration = lotateDuration
        anim.repeatCount = HUGE
        anim.fromValue = 0
        anim.toValue = M_PI * 2
        
        return anim
    }
    
    private func groupAnimation() -> CAAnimationGroup {
        let expand = expandAnimation()
        expand.beginTime = 0
        
        let contract = contractAnimation()
        contract.beginTime = strokeDuration
        
        let group = CAAnimationGroup()
