CAShapeLayer和CAGradientLayer

两个动画效果来了解一下CALayer的两个重要的subClass：CAGradientLayer和CAShapeLayer。先看CAShapeLayer，我们做一个和Spark相机一样的圆形进度，每一段有一种颜色，标识不同时间段录的视频。

“”

阅读器

​​CAShapeLayer​​​​CAGradientLayer​​

​

 

两个动画效果来了解一下CALayer的两个重要的subClass：CAGradientLayer和CAShapeLayer。微视录制视频的时候那个进度效果和Spark相机类似，但是个人还是比较喜欢Spark相机的录制的效果。

 

CAShapeLayer

 

我们做一个和Spark相机一样的圆形进度，每一段有一种颜色，标识不同时间段录的视频。

 

首先，我们创建一个UIView的子类叫RecordingCircleOverlayView这样看起来比较有意义，然后我们看到圆形进度条 有一个底色是灰色的圆形轨迹，所以我们创建一个CAShapeLayer，然后提供一个CGPathRef给它的path属性，我们使用 UIBezierPath这个类的 bezierPathWithArcCenter:radius:startAngle:endAngle:clockwise:这个方法给 CAShapeLayer提供path。

 

图中我们可以看到有彩色一些片段，我们使用另外一个CAShapeLayer和同样的CGPathRef作为背景层，由于是同样的Path，所以我们给UIBezierPath创建一个属性，这样不用每次都重复创建。

2. CGPoint arcCenter = CGPointMake(CGRectGetMidY(self.bounds), CGRectGetMidX(self.bounds)); 
3. CGFloat radius = CGRectGetMidX(self.bounds) - insets.top - insets.bottom; 
4.  
5. self.circlePath = [UIBezierPath bezierPathWithArcCenter:arcCenter 
6. radius:radius 
7. startAngle:M_PI 
8. endAngle:-M_PI 
9. clockwise:NO]; 

开始角度M_PI和结束角度-M_PI和Spark相机是一样的逆时针方向，然后我们再创建一个背景层

2. CAShapeLayer *backgroundLayer = [CAShapeLayerlayer]; 
3. backgroundLayer.path = self.circlePath.CGPath; 
4. backgroundLayer.strokeColor = [[UIColor lightGrayColor] CGColor]; 
5. backgroundLayer.fillColor = [[UIColorclearColor] CGColor]; 
6. backgroundLayer.lineWidth = self.strokeWidth; 

然后我们把backgroundLayer添加为RecordingCircleOverlayView的subLayer

2. [self.layer addSublayer:backgroundLayer]; 

如果我们build运行成功的话应该是这样的。

 

现在我们需要一个方法来实现开始和停止进度，如果我们回头去看​​Spark Camera​​, 我们需要按下手指才会开始松开结束，首先UITapGestureRecognizer和UIControlEventTouchUpInside没有方 法检测按下和松开，但是我们可以用UIControlEventTouchDown，但是我们在Reveal里面并没有看到它是这么做的，所以最后决定使 用复写UIResponder的touchesBegan:WithEvent: and touchesEnded:WithEvent:方法来实现。

 

有个这个方法后，我们可以控制CAShapeLayer的strokeEnd的属性大小来实现动画效果，首页我们先设置它的值为0然后把这个layer添加作为子类。

2. CAShapeLayer *progressLayer = [CAShapeLayerlayer]; 
3. progressLayer.path = self.circlePath.CGPath; 
4. progressLayer.strokeColor = [[selfrandomColor] CGColor]; 
5. progressLayer.fillColor = [[UIColorclearColor] CGColor]; 
6. progressLayer.lineWidth = self.strokeWidth; 
7. progressLayer.strokeEnd = 0.f; 

然后我们发现有多个CAShapeLayer分别代表不同的段，而且每个CAShapeLayer都有自己的strokeEnd,所以我们创建一个数组，把每一个CAShapeLayer添加到数组里。

2. [self.progressLayers addObject:progressLayer]; 

继而我们又需要一个属性代表当前的正在增加可以动画的片段，所以我们添加一个属性来记录当前的进度的layer。

2. self.currentProgressLayer = progressLayer; 

所以最后方法看起来是这样的。

2. - (void)addNewLayer 
3. { 
4.     CAShapeLayer *progressLayer = [CAShapeLayer layer]; 
5.     progressLayer.path = self.circlePath.CGPath; 
6.     progressLayer.strokeColor = [[self randomColor] CGColor]; 
7.     progressLayer.fillColor = [[UIColor clearColor] CGColor]; 
8.     progressLayer.lineWidth = self.strokeWidth; 
9.     progressLayer.strokeEnd = 0.f; 
10.  
11.     [self.layer addSublayer:progressLayer]; 
12.     [self.progressLayers addObject:progressLayer]; 
13.  
14.     self.currentProgressLayer = progressLayer; 
15. } 

为了让它可以有动画，我们有两个重点，其一我们可以使用rotation transform属性，但是我们使用CAShapeLayer的strokeStart和strokeEnd结合起来实现动画，其二停止动画后我们可以 使用截图当前的状态同时移除动画，这样就可以保留每个状态的颜色。为了实现这些，我们使用CABasicAnimation和CAlayer的属性 presentationLayer，直接上代码。

2. - (void)updateAnimations 
3. { 
4.     CGFloat duration = self.duration * (1.f - [[self.progressLayers firstObject] strokeEnd]); 
5.     CGFloat strokeEndFinal = 1.f; 
6.  
7.     for (CAShapeLayer *progressLayer in self.progressLayers) 
8.     { 
9.         CABasicAnimation *strokeEndAnimation = nil; 
10.         strokeEndAnimation = [CABasicAnimation animationWithKeyPath:@"strokeEnd"]; 
11.         strokeEndAnimation.duration = duration; 
12.         strokeEndAnimation.fromValue = @(progressLayer.strokeEnd); 
13.         strokeEndAnimation.toValue = @(strokeEndFinal); 
14.         strokeEndAnimation.autoreverses = NO; 
15.         strokeEndAnimation.repeatCount = 0.f; 
16.         strokeEndAnimation.fillMode = kCAFillModeForwards; 
17.         strokeEndAnimation.removedOnCompletion = NO; 
18.         strokeEndAnimation.delegate = self; 
19.         [progressLayer addAnimation:strokeEndAnimation forKey:@"strokeEndAnimation"]; 
20.  
21.         strokeEndFinal -= (progressLayer.strokeEnd - progressLayer.strokeStart); 
22.  
23.         if (progressLayer != self.currentProgressLayer) 
24.         { 
25.             CABasicAnimation *strokeStartAnimation = nil; 
26.             strokeStartAnimation = [CABasicAnimation animationWithKeyPath:@"strokeStart"]; 
27.             strokeStartAnimation.duration = duration; 
28.             strokeStartAnimation.fromValue = @(progressLayer.strokeStart); 
29.             strokeStartAnimation.toValue = @(strokeEndFinal); 
30.             strokeStartAnimation.autoreverses = NO; 
31.             strokeStartAnimation.repeatCount = 0.f; 
32.             strokeStartAnimation.fillMode = kCAFillModeForwards; 
33.             strokeStartAnimation.removedOnCompletion = NO; 
34.             [progressLayer addAnimation:strokeStartAnimation forKey:@"strokeStartAnimation"]; 
35.         } 
36.     } 
37.     CABasicAnimation *backgroundLayerAnimation = [CABasicAnimation animationWithKeyPath:@"strokeStart"]; 
38.     backgroundLayerAnimation.duration = duration; 
39.     backgroundLayerAnimation.fromValue = @(self.backgroundLayer.strokeStart); 
40.     backgroundLayerAnimation.toValue = @(1.f); 
41.     backgroundLayerAnimation.autoreverses = NO; 
42.     backgroundLayerAnimation.repeatCount = 0.f; 
43.     backgroundLayerAnimation.fillMode = kCAFillModeForwards; 
44.     backgroundLayerAnimation.removedOnCompletion = NO; 
45.     backgroundLayerAnimation.delegate = self; 
46.     [self.backgroundLayer addAnimation:backgroundLayerAnimation forKey:@"strokeStartAnimation"]; 
47. } 

上面代码中我们看到我们遍历了所有的CAShapeLayer,给每个strokeEnd添加了CABasicAnimation动画，然后给 不是当前的layer的strokeStart属性添加了一个动画。再来看看duration，假设一圈代表45秒钟，这个意味着每次停止之后又开始的话 duration肯定是减少的，所以用duration代表一圈剩余的可以录制的时间，再看strekeEndFinal，假设有很多段，肯定不是每个段 的strkeEnd都是1所以这个是用来标识每段可以达到的最终距离一圈为(0-1)。最后我们需要更新background layer除去有彩色段剩余的地方。

你可能注意到上面的代码里面并没有移除动画，所以对于显示每一个CAShapeLayer我们设置都是通过layers的presentationLayer设置strokeStart和strokeEnd，然后移除CAShapeLayer上的所有动画。

 

presentationLayer在文档中是这么说的：

 

“While an animation is in progress, you can retrieve this object and use it to get the current values for those animations.”

 

所以把上面所说的结合起来，代码应该是这样的。

2. - (void)removeAnimations 
3. { 
4.     for (CAShapeLayer *progressLayer in self.progressLayers) 
5.     { 
6.         progressLayer.strokeStart = [progressLayer.presentationLayer strokeStart]; 
7.         progressLayer.strokeEnd = [progressLayer.presentationLayer strokeEnd]; 
8.         [progressLayer removeAllAnimations]; 
9.     } 
10.     self.backgroundLayer.strokeStart = [self.backgroundLayer.presentationLayer strokeStart]; 
11.     [self.backgroundLayer removeAllAnimations]; 
12. } 

最后，还有一个问题是我们需要确保我们完成了动画以后手指按下不要保持添加layer和更新动画这些操作，所以我们可以设置一个代理方法像这样，就大功告成了。

2. - (void)animationDidStop:(CAAnimation *)anim finished:(BOOL)flag 
3. { 
4.     if (self.hasFinishedAnimating == NO && flag) 
5.     { 
6.         [self removeAnimations]; 
7.         self.finishedAnimating = flag; 
8.     } 
9. } 

最后你可以在​​github​​上面下载这个项目。

 

CAGradientLayer

 

首页我们创建一个UIView的子类，然后我们使用CAGradientLayer作为默认的CALayer。

2. + (Class)layerClass { 
3.     return [CAGradientLayer class]; 
4. } 

CAGradientLayer是CALayer的一个子类，添加了一些额外的属性，我们将是使用colors,startPoint,endPoint这些来创建一个有梯度的动画.

现在有几个方法来实现这种彩色的效果，一种是我现在将要使用的创建一个包含UIColor的数组，有不同的色调的值，在你的initWithFrame方法里添加一下代码：

2. // Use a horizontal gradient  
3. CAGradientLayer *layer = (id)[self layer]; 
4. [layer setStartPoint:CGPointMake(0.0, 0.5)]; 
5. [layer setEndPoint:CGPointMake(1.0, 0.5)]; 
6.  
7. // Create colors using hues in +5 increments 
8. NSMutableArray *colors = [NSMutableArray array]; 
9. for (NSInteger hue = 0; hue <= 360; hue += 5) { 
10.  
11.     UIColor *color; 
12.     color = [UIColor colorWithHue:1.0 * hue / 360.0 
13.                        saturation:1.0 
14.                        brightness:1.0 
15.                             alpha:1.0]; 
16.     [colors addObject:(id)[color CGColor]]; 
17. } 
18. [layer setColors:[NSArray arrayWithArray:colors]]; 

现在运行你可以看见一个水平光谱图，下一步创建移动的效果，我们可以遍历这个颜色的数组使用layer animation,一个动画结束的时候会前面的颜色方法最后重复这个进度，方法是这样：

2. - (void)performAnimation { 
3.     // Move the last color in the array to the front 
4.     // shifting all the other colors. 
5.     CAGradientLayer *layer = (id)[self layer]; 
6.     NSMutableArray *mutable = [[layer colors] mutableCopy]; 
7.     id lastColor = [[mutable lastObject] retain]; 
8.     [mutable removeLastObject]; 
9.     [mutable insertObject:lastColor atIndex:0]; 
10.     [lastColor release]; 
11.     NSArray *shiftedColors = [NSArray arrayWithArray:mutable]; 
12.     [mutable release]; 
13.  
14.     // Update the colors on the model layer 
15.     [layer setColors:shiftedColors]; 
16.  
17.     // Create an animation to slowly move the gradient left to right. 
18.     CABasicAnimation *animation; 
19.     animation = [CABasicAnimation animationWithKeyPath:@"colors"]; 
20.     [animation setToValue:shiftedColors]; 
21.     [animation setDuration:0.08]; 
22.     [animation setRemovedOnCompletion:YES]; 
23.     [animation setFillMode:kCAFillModeForwards]; 
24.     [animation setDelegate:self]; 
25.     [layer addAnimation:animation forKey:@"animateGradient"]; 
26. } 
27.  
28. - (void)animationDidStop:(CAAnimation *)animation finished:(BOOL)flag { 
29.     [self performAnimation]; 
30. } 

为了增加一个标识进度的进行，我们可以使用mask属性来屏蔽一部分，在头文件中添加两个属性：

2. @property (nonatomic, readonly) CALayer *maskLayer; 
3. @property (nonatomic, assign) CGFloat progress; 

然后在initWithFrame:里面添加：

2. maskLayer = [CALayer layer]; 
3. [maskLayer setFrame:CGRectMake(0, 0, 0, frame.size.height)]; 
4. [maskLayer setBackgroundColor:[[UIColor blackColor] CGColor]]; 
5. [layer setMask:maskLayer]; 

创建一个宽度为0的mask覆盖整个View，mask的颜色不重要，当我们progress属性更新的时候我们会增加它的宽度，所以复写setProgress:方法像下面这样：

2. - (void)setProgress:(CGFloat)value { 
3.     if (progress != value) { 
4.         // Progress values go from 0.0 to 1.0 
5.         progress = MIN(1.0, fabs(value)); 
6.         [self setNeedsLayout]; 
7.     } 
8. } 
9.  
10. - (void)layoutSubviews { 
11.     // Resize our mask layer based on the current progress 
12.     CGRect maskRect = [maskLayer frame]; 
13.     maskRect.size.width = CGRectGetWidth([self bounds]) * progress; 
14.     [maskLayer setFrame:maskRect]; 
15. } 

现在当我们设置progress值的时候我们要确保它在0到1之间，然后下一步在layoutSubviews里面我们重新定义mask的值。