❌

阅读视图

发现新文章，点击刷新页面。

05-iOS 多媒体技术| Core Animation要点回顾2【UIKit动画、Core Animation动画、粒子动画、经典第三方动画库等】

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

前言

我们在前面,首先进行了针对 iOS中的多媒体技术相关几个框架概述:

  1. 进而 用 两篇文章 对 其中的 UIKit相关要点 进行了分述:
  2. 我们 在此篇文章 ,将 针对 Core Animation框架的要点 进一步展开分述:

一、 iOS 中 动画实现的几种方式

  • UIKit动画
    • 普通动画
    • block动画
    • 关键帧动画
  • Core Animation动画
    • CAAnimationGroup
    • CATransaction
    • CAPropertyAnimation
      • CAKeyframeAnimation
      • CABasicAnimation
        • CASpringAnimation
  • UIImageView帧动画
  • 经典第三方动画库

二、UIKit动画

1. 可动画属性:

UIView动画能够设置的动画属性有:

  • frame
  • bounds
  • center
  • transform
  • alpha
  • backgroundColor
  • contentStretch

UIView动画支持几种动画类型,一般 对View的可动画属性的修改添加动画,直接用 Block动画就足够了

2. 普通动画

开始动画语句:

// 第一个参数: 动画标识
// 第二个参数: 附加参数,在设置代理情况下，此参数将发送到setAnimationWillStartSelector和setAnimationDidStopSelector所指定的方法，大部分情况，设置为nil.
[UIView beginAnimations:(nullable NSString *) context:(nullable void *)];

结束动画语句:

[UIView commitAnimations];

动画参数的属性设置:

//动画持续时间
[UIView setAnimationDuration:(NSTimeInterval)];
//动画的代理对象 
[UIView setAnimationDelegate:(nullable id)];
//设置动画将开始时代理对象执行的SEL
[UIView setAnimationWillStartSelector:(nullable SEL)];
//设置动画延迟执行的时间
[UIView setAnimationDelay:(NSTimeInterval)];
//设置动画的重复次数
[UIView setAnimationRepeatCount:(float)];
//设置动画的曲线
/*
UIViewAnimationCurve的枚举值：
UIViewAnimationCurveEaseInOut,         // 慢进慢出（默认值）
UIViewAnimationCurveEaseIn,            // 慢进
UIViewAnimationCurveEaseOut,           // 慢出
UIViewAnimationCurveLinear             // 匀速
*/
[UIView setAnimationCurve:(UIViewAnimationCurve)];
//设置是否从当前状态开始播放动画
/*假设上一个动画正在播放，且尚未播放完毕，我们将要进行一个新的动画：
当为YES时：动画将从上一个动画所在的状态开始播放
当为NO时：动画将从上一个动画所指定的最终状态开始播放（此时上一个动画马上结束）*/
[UIView setAnimationBeginsFromCurrentState:YES];
//设置动画是否继续执行相反的动画
[UIView setAnimationRepeatAutoreverses:(BOOL)];
//是否禁用动画效果（对象属性依然会被改变，只是没有动画效果）
[UIView setAnimationsEnabled:(BOOL)];
//设置视图的过渡效果
/* 第一个参数：UIViewAnimationTransition的枚举值如下
     UIViewAnimationTransitionNone,              //不使用动画
     UIViewAnimationTransitionFlipFromLeft,      //从左向右旋转翻页
     UIViewAnimationTransitionFlipFromRight,     //从右向左旋转翻页
     UIViewAnimationTransitionCurlUp,            //从下往上卷曲翻页
     UIViewAnimationTransitionCurlDown,          //从上往下卷曲翻页
 第二个参数：需要过渡效果的View
 第三个参数：是否使用视图缓存，YES：视图在开始和结束时渲染一次；NO：视图在每一帧都渲染*/
[UIView setAnimationTransition:(UIViewAnimationTransition) forView:(nonnull UIView *) cache:(BOOL)];

更详细的API说明:

/** 动画的曲线枚举 */
typedef NS_ENUM(NSInteger, UIViewAnimationCurve) {
    UIViewAnimationCurveEaseInOut,  //!< 慢进慢出（默认值）.
    UIViewAnimationCurveEaseIn,     //!< 慢进.
    UIViewAnimationCurveEaseOut,    //!< 慢出.
    UIViewAnimationCurveLinear,     //!< 匀速.
};

/** UIView动画过渡效果 */
typedef NS_ENUM(NSInteger, UIViewAnimationTransition) {
    UIViewAnimationTransitionNone,          //!< 无效果.
    UIViewAnimationTransitionFlipFromLeft,  //!< 沿视图垂直中心轴左到右移动.
    UIViewAnimationTransitionFlipFromRight, //!< 沿视图垂直中心轴右到左移动.
    UIViewAnimationTransitionCurlUp,        //!< 由底部向上卷起.
    UIViewAnimationTransitionCurlDown,      //!< 由顶部向下展开.
};

@interface UIView(UIViewAnimation)
 
/** 开始动画 */
+ (void)beginAnimations:(nullable NSString *)animationID context:(nullable void *)context;
/** 提交动画 */
+ (void)commitAnimations;
 
/** 设置动画代理, 默认nil */
+ (void)setAnimationDelegate:(nullable id)delegate;
/** 动画将要开始时执行方法（必须要先设置动画代理）, 默认NULL */
+ (void)setAnimationWillStartSelector:(nullable SEL)selector;
/** 动画已结束时执行方法（必须要先设置动画代理）, 默认NULL */
+ (void)setAnimationDidStopSelector:(nullable SEL)selector;
/** 设置动画时长, 默认0.2秒 */
+ (void)setAnimationDuration:(NSTimeInterval)duration;
/** 动画延迟执行时间, 默认0.0秒 */
+ (void)setAnimationDelay:(NSTimeInterval)delay;
/** 设置在动画块内部动画属性改变的开始时间, 默认now ([NSDate date]) */
+ (void)setAnimationStartDate:(NSDate *)startDate;
/** 设置动画曲线, 默认UIViewAnimationCurveEaseInOut */
+ (void)setAnimationCurve:(UIViewAnimationCurve)curve;
/** 动画的重复播放次数， 默认0 */
+ (void)setAnimationRepeatCount:(float)repeatCount;
/** 设置是否自定翻转当前的动画效果, 默认NO */
+ (void)setAnimationRepeatAutoreverses:(BOOL)repeatAutoreverses;
/** 设置动画从当前状态开始播放, 默认NO */
+ (void)setAnimationBeginsFromCurrentState:(BOOL)fromCurrentState;
 
/** 在动画块中为视图设置过渡动画 */
+ (void)setAnimationTransition:(UIViewAnimationTransition)transition forView:(UIView *)view cache:(BOOL)cache;
 
/** 设置是否激活动画 */
+ (void)setAnimationsEnabled:(BOOL)enabled;
/** 返回一个布尔值表示动画是否结束 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(class, nonatomic, readonly) BOOL areAnimationsEnabled;
#else
+ (BOOL)areAnimationsEnabled;
#endif
/** 先检查动画当前是否启用，然后禁止动画，执行block内的方法，最后重新启用动画，而且这个方法不会阻塞基于CoreAnimation的动画 */
+ (void)performWithoutAnimation:(void (NS_NOESCAPE ^)(void))actionsWithoutAnimation NS_AVAILABLE_IOS(7_0);
 
/** 当前动画的持续时间 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(class, nonatomic, readonly) NSTimeInterval inheritedAnimationDuration NS_AVAILABLE_IOS(9_0);
#else
+ (NSTimeInterval)inheritedAnimationDuration NS_AVAILABLE_IOS(9_0);
#endif
 
@end

Demo示例1:

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    UITouch *tuch = touches.anyObject;
    CGPoint point = [tuch locationInView:self.view];
    
    [UIView beginAnimations:@"testAnimation" context:nil];
    [UIView setAnimationDuration:3.0];
    [UIView setAnimationDelegate:self];
    //设置动画将开始时代理对象执行的SEL
    [UIView setAnimationWillStartSelector:@selector(animationDoing)];
    
    //设置动画延迟执行的时间
    [UIView setAnimationDelay:0];
    
    [UIView setAnimationRepeatCount:MAXFLOAT];
    [UIView setAnimationCurve:UIViewAnimationCurveLinear];
    //设置动画是否继续执行相反的动画
    [UIView setAnimationRepeatAutoreverses:YES];
    self.redView.center = point;
    self.redView.transform = CGAffineTransformMakeScale(1.5, 1.5);
    self.redView.transform = CGAffineTransformMakeRotation(M_PI);
    
    [UIView commitAnimations];
}

Demo示例2:

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    UITouch *tuch = touches.anyObject;
    CGPoint point = [tuch locationInView:self.view];
    
    [UIView beginAnimations:@"testAnimation" context:nil];
    [UIView setAnimationDuration:3.0];
    [UIView setAnimationDelegate:self];
    //设置动画将开始时代理对象执行的SEL
    [UIView setAnimationWillStartSelector:@selector(animationDoing)];
    
    //设置动画延迟执行的时间
    [UIView setAnimationDelay:0];
    
    [UIView setAnimationRepeatCount:MAXFLOAT];
    [UIView setAnimationCurve:UIViewAnimationCurveLinear];
    //设置动画是否继续执行相反的动画
    [UIView setAnimationRepeatAutoreverses:YES];
    self.redView.center = point;
    self.redView.transform = CGAffineTransformMakeScale(1.5, 1.5);
    self.redView.transform = CGAffineTransformMakeRotation(M_PI);
    
    [UIView commitAnimations];
}

Demo示例3:

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    // 转成动画 (flip)
    [UIView beginAnimations:@"imageViewTranslation" context:nil];
    [UIView setAnimationDuration:2.0];
    [UIView setAnimationDelegate:self];
    [UIView setAnimationWillStartSelector:@selector(startAnimation)];
    [UIView setAnimationDidStopSelector:@selector(stopAnimation)];
    [UIView setAnimationRepeatCount:1.0];
    [UIView setAnimationCurve:UIViewAnimationCurveEaseInOut];
    [UIView setAnimationRepeatAutoreverses:YES];
    [UIView setAnimationRepeatCount:MAXFLOAT];
    [UIView setAnimationTransition:UIViewAnimationTransitionFlipFromLeft forView:self.imageView cache:YES];
    if (++count % 2 ==0) {
        self.imageView.image = [UIImage imageNamed:@"yh_detial_ty"];
    }else{
        self.imageView.image = [UIImage imageNamed:@"yh_detial_bz"];
    }
    [UIView commitAnimations];
    
}

3. block动画

iOS4.0以后增加了Block动画块，提供了更简洁的方式来实现动画.日常开发中一般也是使用Block形式创建动画。

最简洁的Block动画:包含时间和动画:

[UIView animateWithDuration:(NSTimeInterval)  //动画持续时间
              animations:^{
              //执行的动画
 }];

带有动画提交回调的Block动画

 [UIView animateWithDuration:(NSTimeInterval)  //动画持续时间
              animations:^{
            //执行的动画
 }                completion:^(BOOL finished) {
            //动画执行提交后的操作
 }];

可以设置延时时间和过渡效果的Block动画

[UIView animateWithDuration:(NSTimeInterval) //动画持续时间
                   delay:(NSTimeInterval) //动画延迟执行的时间
                 options:(UIViewAnimationOptions) //动画的过渡效果
              animations:^{
               //执行的动画
 }                completion:^(BOOL finished) {
               //动画执行提交后的操作
 }];

UIViewAnimationOptions的枚举值如下,可组合使用:

 UIViewAnimationOptionLayoutSubviews            //进行动画时布局子控件
 UIViewAnimationOptionAllowUserInteraction      //进行动画时允许用户交互
 UIViewAnimationOptionBeginFromCurrentState     //从当前状态开始动画
 UIViewAnimationOptionRepeat                    //无限重复执行动画
 UIViewAnimationOptionAutoreverse               //执行动画回路
 UIViewAnimationOptionOverrideInheritedDuration //忽略嵌套动画的执行时间设置
 UIViewAnimationOptionOverrideInheritedCurve    //忽略嵌套动画的曲线设置
 UIViewAnimationOptionAllowAnimatedContent      //转场：进行动画时重绘视图
 UIViewAnimationOptionShowHideTransitionViews   //转场：移除（添加和移除图层的）动画效果
 UIViewAnimationOptionOverrideInheritedOptions  //不继承父动画设置

 UIViewAnimationOptionCurveEaseInOut            //时间曲线，慢进慢出（默认值）
 UIViewAnimationOptionCurveEaseIn               //时间曲线，慢进
 UIViewAnimationOptionCurveEaseOut              //时间曲线，慢出
 UIViewAnimationOptionCurveLinear               //时间曲线，匀速

 UIViewAnimationOptionTransitionNone            //转场，不使用动画
 UIViewAnimationOptionTransitionFlipFromLeft    //转场，从左向右旋转翻页
 UIViewAnimationOptionTransitionFlipFromRight   //转场，从右向左旋转翻页
 UIViewAnimationOptionTransitionCurlUp          //转场，下往上卷曲翻页
 UIViewAnimationOptionTransitionCurlDown        //转场，从上往下卷曲翻页
 UIViewAnimationOptionTransitionCrossDissolve   //转场，交叉消失和出现
 UIViewAnimationOptionTransitionFlipFromTop     //转场，从上向下旋转翻页
 UIViewAnimationOptionTransitionFlipFromBottom  //转场，从下向上旋转翻页

Spring动画

iOS7.0以后新增了Spring动画(IOS系统动画大部分采用Spring Animation， 适用所有可被添加动画效果的属性)

 [UIView animateWithDuration:(NSTimeInterval)//动画持续时间
                   delay:(NSTimeInterval)//动画延迟执行的时间
  usingSpringWithDamping:(CGFloat)//震动效果，范围0~1，数值越小震动效果越明显
   initialSpringVelocity:(CGFloat)//初始速度，数值越大初始速度越快
                 options:(UIViewAnimationOptions)//动画的过渡效果
              animations:^{
                 //执行的动画
 }
                  completion:^(BOOL finished) {
                 //动画执行提交后的操作
 }];

更详细的API说明:


/** UIView动画选项 */
typedef NS_OPTIONS(NSUInteger, UIViewAnimationOptions) {
    UIViewAnimationOptionLayoutSubviews            = 1 <<  0, //!< 动画过程中保证子视图跟随运动.
    UIViewAnimationOptionAllowUserInteraction      = 1 <<  1, //!< 动画过程中允许用户交互.
    UIViewAnimationOptionBeginFromCurrentState     = 1 <<  2, //!< 所有视图从当前状态开始运行.
    UIViewAnimationOptionRepeat                    = 1 <<  3, //!< 重复运行动画.
    UIViewAnimationOptionAutoreverse               = 1 <<  4, //!< 动画运行到结束点后仍然以动画方式回到初始点.
    UIViewAnimationOptionOverrideInheritedDuration = 1 <<  5, //!< 忽略嵌套动画时间设置.
    UIViewAnimationOptionOverrideInheritedCurve    = 1 <<  6, //!< 忽略嵌套动画速度设置.
    UIViewAnimationOptionAllowAnimatedContent      = 1 <<  7, //!< 动画过程中重绘视图（注意仅仅适用于转场动画）.
    UIViewAnimationOptionShowHideTransitionViews   = 1 <<  8, //!< 视图切换时直接隐藏旧视图、显示新视图，而不是将旧视图从父视图移除（仅仅适用于转场动画）.
    UIViewAnimationOptionOverrideInheritedOptions  = 1 <<  9, //!< 不继承父动画设置或动画类型.
    
    UIViewAnimationOptionCurveEaseInOut            = 0 << 16, //!< 动画先缓慢，然后逐渐加速.
    UIViewAnimationOptionCurveEaseIn               = 1 << 16, //!< 动画逐渐变慢.
    UIViewAnimationOptionCurveEaseOut              = 2 << 16, //!< 动画逐渐加速.
    UIViewAnimationOptionCurveLinear               = 3 << 16, //!< 动画匀速执行，默认值.
    
    UIViewAnimationOptionTransitionNone            = 0 << 20, //!< 没有转场动画效果.
    UIViewAnimationOptionTransitionFlipFromLeft    = 1 << 20, //!< 从左侧翻转效果.
    UIViewAnimationOptionTransitionFlipFromRight   = 2 << 20, //!< 从右侧翻转效果.
    UIViewAnimationOptionTransitionCurlUp          = 3 << 20, //!< 向后翻页的动画过渡效果.
    UIViewAnimationOptionTransitionCurlDown        = 4 << 20, //!< 向前翻页的动画过渡效果.
    UIViewAnimationOptionTransitionCrossDissolve   = 5 << 20, //!< 旧视图溶解消失显示下一个新视图的效果.
    UIViewAnimationOptionTransitionFlipFromTop     = 6 << 20, //!< 从上方翻转效果.
    UIViewAnimationOptionTransitionFlipFromBottom  = 7 << 20, //!< 从底部翻转效果.
    
    UIViewAnimationOptionPreferredFramesPerSecondDefault     = 0 << 24, //!< 默认的帧每秒.
    UIViewAnimationOptionPreferredFramesPerSecond60          = 3 << 24, //!< 60帧每秒的帧速率.
    UIViewAnimationOptionPreferredFramesPerSecond30          = 7 << 24, //!< 30帧每秒的帧速率.
    
} NS_ENUM_AVAILABLE_IOS(4_0);

 
@interface UIView(UIViewAnimationWithBlocks)
 
/** 用于对一个或多个视图的改变的持续时间、延时、选项动画完成时的操作 */
+ (void)animateWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);
 
/** 用于对一个或多个视图的改变的持续时间、选项动画完成时的操作，默认：delay = 0.0, options = 0 */
+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);
 
/** 用于对一个或多个视图的改变的持续时间内动画完成时的操作，默认：delay = 0.0, options = 0, completion = NULL */
+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations NS_AVAILABLE_IOS(4_0);
 
/** 使用与物理弹簧运动相对应的定时曲线执行视图动画 */
+ (void)animateWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay usingSpringWithDamping:(CGFloat)dampingRatio initialSpringVelocity:(CGFloat)velocity options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(7_0);
 
/** 为指定的容器视图创建转换动画 */
+ (void)transitionWithView:(UIView *)view duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^ __nullable)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);
 
/** 使用给定的参数在指定视图之间创建转换动画 */
+ (void)transitionFromView:(UIView *)fromView toView:(UIView *)toView duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0); // toView added to fromView.superview, fromView removed from its superview
 
/** 在一个或多个视图上执行指定的系统提供的动画，以及定义的可选并行动画 */
+ (void)performSystemAnimation:(UISystemAnimation)animation onViews:(NSArray<__kindof UIView *> *)views options:(UIViewAnimationOptions)options animations:(void (^ __nullable)(void))parallelAnimations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(7_0);
 
@end

Demo示例1

[UIView animateWithDuration:3.0 animations:^{
        
        self.redView.center = point;
        self.redView.transform = CGAffineTransformMakeScale(1.5, 1.5);
        self.redView.transform = CGAffineTransformMakeRotation(M_PI);
    } completion:^(BOOL finished) {
        [UIView animateWithDuration:2.0 animations:^{
            self.redView.frame = CGRectMake(100, 100, 100, 100);
            self.redView.transform = CGAffineTransformMakeScale(1 / 1.5,1 / 1.5);
            self.redView.transform = CGAffineTransformMakeRotation(M_PI);
        }];
    }];

Demo示例2

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    self.redView.alpha = 0;
/*
animateWithDuration 动画持续时间
delay 动画延迟执行的时间
usingSpringWithDamping 震动效果，范围0~1，数值越小震动效果越明显
initialSpringVelocity 初始速度，数值越大初始速度越快
options 动画的过渡效果
*/
    [UIView animateWithDuration:3.0  delay:1.0 usingSpringWithDamping:0.3 initialSpringVelocity:1 options:UIViewAnimationOptionAllowUserInteraction animations:^{
        self.redView.alpha = 1.0;
        self.redView.frame = CGRectMake(200, 350, 140, 140);
    } completion:^(BOOL finished) {
        [self.redView removeFromSuperview];
    }];
}

4. 关键帧动画

IOS7.0后新增了关键帧动画，支持属性关键帧，不支持路径关键帧

 [UIView animateKeyframesWithDuration:(NSTimeInterval)//动画持续时间
                            delay:(NSTimeInterval)//动画延迟执行的时间
                          options:(UIViewKeyframeAnimationOptions)//动画的过渡效果
                       animations:^{
                     //执行的关键帧动画
 }
                       completion:^(BOOL finished) {
                     //动画执行提交后的操作
 }];

UIViewKeyframeAnimationOptions的枚举值如下，可组合使用:

UIViewAnimationOptionLayoutSubviews           //进行动画时布局子控件
UIViewAnimationOptionAllowUserInteraction     //进行动画时允许用户交互
UIViewAnimationOptionBeginFromCurrentState    //从当前状态开始动画
UIViewAnimationOptionRepeat                   //无限重复执行动画
UIViewAnimationOptionAutoreverse              //执行动画回路
UIViewAnimationOptionOverrideInheritedDuration //忽略嵌套动画的执行时间设置
UIViewAnimationOptionOverrideInheritedOptions //不继承父动画设置

UIViewKeyframeAnimationOptionCalculationModeLinear     //运算模式 :连续
UIViewKeyframeAnimationOptionCalculationModeDiscrete   //运算模式 :离散
UIViewKeyframeAnimationOptionCalculationModePaced      //运算模式 :均匀执行
UIViewKeyframeAnimationOptionCalculationModeCubic      //运算模式 :平滑
UIViewKeyframeAnimationOptionCalculationModeCubicPaced //运算模式 :平滑均匀

各种运算模式的直观比较如下图：

增加关键帧方法:

[UIView addKeyframeWithRelativeStartTime:(double)//动画开始的时间（占总时间的比例）
                     relativeDuration:(double) //动画持续时间（占总时间的比例）
                           animations:^{
                         //执行的动画
 }];

转场动画:
a.从旧视图到新视图的动画效果

[UIView transitionFromView:(nonnull UIView *) toView:(nonnull UIView *) duration:(NSTimeInterval) options:(UIViewAnimationOptions) completion:^(BOOL finished) {
                 //动画执行提交后的操作
 }];

在该动画过程中，fromView 会从父视图中移除，并将 toView 添加到父视图中，注意转场动画的作用对象是父视图（过渡效果体现在父视图上）。调用该方法相当于执行下面两句代码:

[fromView.superview addSubview:toView];
[fromView removeFromSuperview];

单个视图的过渡效果

[UIView transitionWithView:(nonnull UIView *)
               duration:(NSTimeInterval)
                options:(UIViewAnimationOptions)
             animations:^{
             //执行的动画
 }
             completion:^(BOOL finished) {
             //动画执行提交后的操作
 }];

更详细的API说明:

typedef NS_OPTIONS(NSUInteger, UIViewKeyframeAnimationOptions) {
    UIViewKeyframeAnimationOptionLayoutSubviews            = UIViewAnimationOptionLayoutSubviews, //!< 动画过程中保证子视图跟随运动.
    UIViewKeyframeAnimationOptionAllowUserInteraction      = UIViewAnimationOptionAllowUserInteraction, //!< 动画过程中允许用户交互.
    UIViewKeyframeAnimationOptionBeginFromCurrentState     = UIViewAnimationOptionBeginFromCurrentState, //!< 所有视图从当前状态开始运行.
    UIViewKeyframeAnimationOptionRepeat                    = UIViewAnimationOptionRepeat, //!< 重复运行动画.
    UIViewKeyframeAnimationOptionAutoreverse               = UIViewAnimationOptionAutoreverse, //!< 动画运行到结束点后仍然以动画方式回到初始点.
    UIViewKeyframeAnimationOptionOverrideInheritedDuration = UIViewAnimationOptionOverrideInheritedDuration, //!< 忽略嵌套动画时间设置.
    UIViewKeyframeAnimationOptionOverrideInheritedOptions  = UIViewAnimationOptionOverrideInheritedOptions, //!< 不继承父动画设置或动画类型.
    
    UIViewKeyframeAnimationOptionCalculationModeLinear     = 0 << 10, //!< 连续运算模式, 默认.
    UIViewKeyframeAnimationOptionCalculationModeDiscrete   = 1 << 10, //!< 离散运算模式.
    UIViewKeyframeAnimationOptionCalculationModePaced      = 2 << 10, //!< 均匀执行运算模式.
    UIViewKeyframeAnimationOptionCalculationModeCubic      = 3 << 10, //!< 平滑运算模式.
    UIViewKeyframeAnimationOptionCalculationModeCubicPaced = 4 << 10  //!< 平滑均匀运算模式.
} NS_ENUM_AVAILABLE_IOS(7_0);

/** UIView的关键帧动画 */
@interface UIView (UIViewKeyframeAnimations)
 
/** 创建一个动画块对象，可用于为当前视图设置基于关键帧的动画 */
+ (void)animateKeyframesWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay options:(UIViewKeyframeAnimationOptions)options animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(7_0);
/** 添加指定开始时间、持续时间的关键帧动画(起始和持续时间是0.0和1.0之间的值) */
+ (void)addKeyframeWithRelativeStartTime:(double)frameStartTime relativeDuration:(double)frameDuration animations:(void (^)(void))animations NS_AVAILABLE_IOS(7_0);
 
@end

三、Core Animation动画

说到核心动画，那就不得不先说下 CALayer。

  • 在iOS系统中，你能看得见摸得着的东西基本上都是UIView，比如一个按钮、一个文本标签、一个文本输入框、一个图标等等，这些都是UIView。
  • 其实UIView之所以能显示在屏幕上，完全是因为它内部的一个layer对象。
  • 在创建UIView对象时，UIView内部会自动创建一个层(即CALayer对象)，通过UIView的layer属性可以访问这个层。当UIView需要显示到屏幕上时，会调用drawRect:方法进行绘图，并且会将所有内容绘制在自己的层上，绘图完毕后，系统会将层拷贝到屏幕上，于是就完成了UIView的显示。
  • 换句话说，UIView本身不具备显示的功能，是它内部的层才有显示功能。

上面已经说过了，UIView之所以能够显示，完全是因为内部的CALayer对象。因此，通过操作这个CALayer对象，可以很方便地调整UIView的一些界面属性，比如: 阴影、圆角大小、边框宽度和颜色等。

1. CALayer的属性回顾

//下面是CALayer的一些属性介绍
//宽度和高度
@property CGRect bounds;

//位置(默认指中点，具体由anchorPoint决定)
@property CGPoint position;

//锚点(x,y的范围都是0-1)，决定了position的含义
@property CGPoint anchorPoint;

//背景颜色(CGColorRef类型)
@propertyCGColorRefbackgroundColor;

//形变属性
@property CATransform3D transform;

//边框颜色(CGColorRef类型)
@property  CGColorRef  borderColor;

//边框宽度
@property CGFloat borderWidth;

//圆角半径
@property CGFloat cornerRadius;

//内容(比如设置为图片CGImageRef)
@property(retain) id contents;

2. 给CALayer的contents赋值

说明：可以通过设置contents属性给UIView设置背景图片,注意必须是CGImage才能显示，我们可以在UIImage对象后面加上.CGImage直接转换，转换之后还需要在前面加上(id)进行强转。

// 跨框架赋值需要进行桥接
self.view.layer.contents = (__bridge id _Nullable)([UIImage imageNamed:@"123"].CGImage);

值得注意的是，UIView的CALayer对象(层)通过layer属性可以访问这个层。要注意的是，这个默认的层不允许重新创建，但可以往层里面添加子层。UIView可以通过addSubview:方法添加子视图，类似地，CALayer可以通过addSublayer:方法添加子层

3. position和anchorPoint

CALayer对象有两个比较重要的属性，那就是position和anchorPoint。

  • position和anchorPoint属性都是CGPoint类型的
  • position可以用来设置CALayer在父层中的位置，它是以父层的左上角为坐标原点(0, 0)
  • anchorPoint称为"锚点"，它决定着CALayer身上的哪个点会在position属性所指的位置。它的x、y取值范围都是0~1，默认值为(0.5, 0.5)
  1. 创建一个CALayer，添加到控制器的view的layer中 
     CALayer *myLayer = [CALayer layer];
// 设置层的宽度和高度（100x100）
myLayer.bounds = CGRectMake(0, 0, 100, 100);
// 设置层的位置
myLayer.position = CGPointMake(100, 100);
// 设置层的背景颜色：红色
myLayer.backgroundColor = [UIColor redColor].CGColor;

// 添加myLayer到控制器的view的layer中
[self.view.layer addSublayer:myLayer];
    第5行设置了myLayer的position为(100, 100)，又因为anchorPoint默认是(0.5, 0.5)，所以最后的效果是：myLayer的中点会在父层的(100, 100)位置

注意，蓝色线是我自己加上去的，方便大家理解，并不是默认的显示效果。两条蓝色线的宽度均为100。

  1. 若将anchorPoint改为(0, 0)，myLayer的左上角会在(100, 100)位置
    myLayer.anchorPoint = CGPointMake(0, 0);

  2. 若将anchorPoint改为(1, 1)，myLayer的右下角会在(100, 100)位置
    myLayer.anchorPoint = CGPointMake(1, 1);

  3. 将anchorPoint改为(0, 1)，myLayer的左下角会在(100, 100)位置
    myLayer.anchorPoint = CGPointMake(0, 1);

我想，你应该已经大概明白anchorPoint的用途了吧，它决定着CALayer身上的哪个点会在position所指定的位置上。它的x、y取值范围都是0~1，默认值为(0.5, 0.5)，因此，默认情况下，CALayer的中点会在position所指定的位置上。当anchorPoint为其他值时，以此类推。
anchorPoint是视图的中心点，position是视图的位置，位置会和中心点重叠。所以我们在开发中可以通过修改视图的layer.anchorPoint或者layer.position实现特定的动画效果。
下面举个两个例子: 两份代码，上面那个是anchorPoint为(0.5, 0.5)也就是默认情况下，下面那个是(0, 0)。

代码如下：

self.redView.layer.anchorPoint = CGPointMake(0.5, 0.5);
[UIView animateWithDuration:3.0 animations:^{
    self.redView.transform = CGAffineTransformMakeRotation(M_PI);
} completion:^(BOOL finished) {

}];

代码如下：

self.redView.layer.anchorPoint = CGPointMake(0, 0);
    [UIView animateWithDuration:3.0 animations:^{
        
        self.redView.transform = CGAffineTransformMakeRotation(M_PI);
    } completion:^(BOOL finished) {
        
    }];

4. CATransaction事务类|隐式动画

注意 CATransaction 不是 CATransition 根层与非根层:

  • 每一个UIView内部都默认关联着一个CALayer，我们可以称这个Layer为Root Layer（根层）
  • 所有的非Root Layer，也就是手动创建的CALayer对象，都存在着隐式动画

当对非Root Layer的部分属性进行修改时，默认会自动产生一些动画效果，而这些属性称为Animatable Properties(可动画属性)。

常见的几个可动画属性：

bounds：用于设置CALayer的宽度和高度。修改这个属性会产生缩放动画
backgroundColor：用于设置CALayer的背景色。修改这个属性会产生背景色的渐变动画
position：用于设置CALayer的位置。修改这个属性会产生平移动画
borderColor:边框颜色
opacity:不透明度

可以通过事务关闭隐式动画:

[CATransaction begin];
// 关闭隐式动画
[CATransaction setDisableActions:YES];

self.myview.layer.position = CGPointMake(10, 10);
[CATransaction commit];
  • CATransaction事务类可以对多个layer的属性同时进行修改，它分隐式事务和显式事务。
  • 当我们向图层添加显式或隐式动画时，Core Animation都会自动创建隐式事务。
  • 但是，我们还可以创建显式事务以更精确地管理这些动画。
  • 区分隐式动画和隐式事务:
    隐式动画通过隐式事务实现动画 。
  • 区分显式动画和显式事务:
    显式动画有多种实现方式，显式事务是一种实现显式动画的方式。
  • 除显式事务外,任何对于CALayer属性的修改,都是隐式事务.

隐式事务

//创建layer
let layer = CALayer()
layer.bounds = CGRect(x: 0, y: 0, width: 100, height: 100)
layer.position = CGPoint(x: 100, y: 350)
layer.backgroundColor = UIColor.red.cgColor
layer.borderColor = UIColor.black.cgColor
layer.opacity = 1.0
view.layer.addSublayer(layer)

//触发动画

// 设置变化动画过程是否显示，默认为true不显示
CATransaction.setDisableActions(false)
layer.cornerRadius = (layer.cornerRadius == 0.0) ? 30.0 : 0.0
layer.opacity = (layer.opacity == 1.0) ? 0.5 : 1.0

显式事务：通过明确的调用begin，commit来提交动画

CATransaction.begin()
layer.zPosition = 200.0
layer.opacity = 0.0
CATransaction.commit()

使用事务CATransaction的主要原因:

  • 在显式事务的范围内，我们可以更改持续时间，计时功能和其他参数。
  • 还可以为整个事务分配完成块，以便在动画组完成时通知应用。

例如，将动画的默认持续时间更改为8秒，使用setValue:forKey:方法进行修改，目前支持的属性包括： "animationDuration", "animationTimingFunction","completionBlock", "disableActions".

CATransaction.begin()
CATransaction.setValue(8.0, forKey: "animationDuration")
//执行动画
CATransaction.commit()

嵌套事务:

  • 当我们要为不同动画集提供不同默认值的情况下可以使用嵌套事务。
  • 要将一个事务嵌套在另一个事务中，只需再次调用begin，且每个begin调用必须一一对应一个commit方法。
  • 只有在为最外层事务提交更改后，Core Animation才会开始关联的动画。

嵌套显式事务代码

//事务嵌套
CATransaction.begin()   // 外部transaction
CATransaction.setValue(2.0, forKey: "animationDuration")
layer.position = CGPoint(x: 140, y: 140)
        
CATransaction.begin()   // 内部transaction
CATransaction.setValue(5.0, forKey: "animationDuration")
layer.zPosition = 200.0
layer.opacity = 0.0
        
CATransaction.commit()  // 内部transaction
CATransaction.commit()  // 外部transaction

5. Core Animation动画简介

  • Core Animation可以用在Mac OS X和iOS平台。
  • Core Animation的动画执行过程都是在后台操作的，不会阻塞主线程。
  • 要注意的是，Core Animation是直接作用在CALayer上的，并非UIView。
  • 乔帮主在2007年的WWDC大会上亲自为你演示Core Animation的强大：点击查看视频

6. 核心动画开发步骤

  1. 使用它需要先添加QuartzCore.framework框架和引入主头文件<QuartzCore/QuartzCore.h> （如果是xcode5之前的版本，使用它需要先添加QuartzCore.framework和引入对应的框架<QuartzCore/QuartzCore.h>）
  2. 初始化一个CAAnimation对象，并设置一些动画相关属性
  3. 通过调用CALayer的addAnimation:forKey:方法增加CAAnimation对象到CALayer中，这样就能开始执行动画了
  4. 通过调用CALayer的removeAnimationForKey:方法可以停止CALayer中的动画

7. CAAnimation——所有动画对象的父类

是所有动画对象的父类，负责控制动画的持续时间和速度，是个抽象类，不能直接使用，应该使用它具体的子类
属性说明：(带*号代表来自CAMediaTiming协议的属性)

  • *duration：动画的持续时间
  • *repeatCount：重复次数，无限循环可以设置HUGE_VALF或者MAXFLOAT
  • *repeatDuration：重复时间
  • removedOnCompletion：默认为YES，代表动画执行完毕后就从图层上移除，图形会恢复到动画执行前的状态。如果想让图层保持显示动画执行后的状态，那就设置为NO，不过还要设置fillMode为kCAFillModeForwards
  • *fillMode：决定当前对象在非active时间段的行为。比如动画开始之前或者动画结束之后
  • *beginTime：可以用来设置动画延迟执行时间，若想延迟2s，就设置为CACurrentMediaTime()+2，CACurrentMediaTime()为图层的当前时间
  • timingFunction：速度控制函数，控制动画运行的节奏
  • delegate：动画代理

8. CAAnimation——动画填充模式

  • fillMode属性值（要想fillMode有效，最好设置removedOnCompletion = NO）
  • kCAFillModeRemoved 这个是默认值，也就是说当动画开始前和动画结束后，动画对layer都没有影响，动画结束后，layer会恢复到之前的状态
  • kCAFillModeForwards 当动画结束后，layer会一直保持着动画最后的状态
  • kCAFillModeBackwards 在动画开始前，只需要将动画加入了一个layer，layer便立即进入动画的初始状态并等待动画开始。
  • kCAFillModeBoth 这个其实就是上面两个的合成.动画加入后开始之前，layer便处于动画初始状态，动画结束后layer保持动画最后的状态

9. CAAnimation——速度控制函数

速度控制函数(CAMediaTimingFunction)

  • kCAMediaTimingFunctionLinear（线性）：匀速，给你一个相对静态的感觉
  • kCAMediaTimingFunctionEaseIn（渐进）：动画缓慢进入，然后加速离开
  • kCAMediaTimingFunctionEaseOut（渐出）：动画全速进入，然后减速的到达目的地
  • kCAMediaTimingFunctionEaseInEaseOut（渐进渐出）：动画缓慢的进入，中间加速，然后减速的到达目的地。这个是默认的动画行为。

设置动画的执行节奏
anim.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionLinear];

10. CAAnimation——动画代理方法

CAAnimation在分类中定义了代理方法,是给NSObject添加的分类,所以任何对象,成为CAAnimation的代理都可以

@interface NSObject (CAAnimationDelegate)

/* Called when the animation begins its active duration. */
动画开始的时候调用
- (void)animationDidStart:(CAAnimation *)anim;
动画停止的时候调用
- (void)animationDidStop:(CAAnimation *)anim finished:(BOOL)flag;

@end

11. CALayer上动画的暂停和恢复

#pragma mark 暂停CALayer的动画
-(void)pauseLayer:(CALayer*)layer
{
    CFTimeInterval pausedTime = [layer convertTime:CACurrentMediaTime() fromLayer:nil];
    //让CALayer的时间停止走动
    layer.speed = 0.0;
    //让CALayer的时间停留在pausedTime这个时刻
    layer.timeOffset = pausedTime;
}

12. CALayer上动画的恢复

#pragma mark 恢复CALayer的动画

-(void)resumeLayer:(CALayer*)layer
{
    CFTimeInterval pausedTime = layer.timeOffset;
    // 1. 让CALayer的时间继续行走
    layer.speed = 1.0;
    // 2. 取消上次记录的停留时刻
    layer.timeOffset = 0.0;
    // 3. 取消上次设置的时间
    layer.beginTime = 0.0;
    // 4. 计算暂停的时间(这里也可以用CACurrentMediaTime()-pausedTime)
    CFTimeInterval timeSincePause = [layer convertTime:CACurrentMediaTime() fromLayer:nil] - pausedTime;
    // 5. 设置相对于父坐标系的开始时间(往后退timeSincePause)
    layer.beginTime = timeSincePause;
}

13. CAPropertyAnimation

是CAAnimation的子类，也是个抽象类，要想创建动画对象，应该使用它的两个子类:

  • CABasicAnimation
  • CAKeyframeAnimation

属性说明：
keyPath：通过指定CALayer的一个属性名称为keyPath（NSString类型），并且对CALayer的这个属性的值进行修改，达到相应的动画效果。比如，指定@“position”为keyPath，就修改CALayer的position属性的值，以达到平移的动画效果

14. CABasicAnimation——基本动画

基本动画，是CAPropertyAnimation的子类

属性说明:

  • keyPath:要改变的属性名称(传字符串)
  • fromValue：keyPath相应属性的初始值
  • toValue：keyPath相应属性的结束值

动画过程说明：

  • 随着动画的进行，在长度为duration的持续时间内，keyPath相应属性的值从fromValue渐渐地变为toValue
  • keyPath内容是CALayer的可动画Animatable属性

如果fillMode=kCAFillModeForwards同时removedOnComletion=NO，那么在动画执行完毕后，图层会保持显示动画执行后的状态。但在实质上，图层的属性值还是动画执行前的初始值，并没有真正被改变。

    //创建动画
    CABasicAnimation *anim = [CABasicAnimation animation];;
    //    设置动画对象
    // keyPath决定了执行怎样的动画,调用layer的哪个属性来执行动画
    //     position:平移
    anim.keyPath = @"position";
    //    包装成对象
    anim.fromValue = [NSValue valueWithCGPoint:CGPointMake(0, 0)];;
    anim.toValue = [NSValue valueWithCGPoint:CGPointMake(200, 300)];
    anim.duration = 2.0;
    
    //    让图层保持动画执行完毕后的状态
    //    执行完毕以后不要删除动画
    anim.removedOnCompletion = NO;
    //    保持最新的状态
    anim.fillMode = kCAFillModeForwards;
    
    //    添加动画
    [self.layer addAnimation:anim forKey:nil];

举个例子: 代码如下:

//创建动画对象
    CABasicAnimation *anim = [CABasicAnimation animation];
    
    //设置动画属性
    anim.keyPath = @"position.y";
    anim.toValue = @300;
    
    //动画提交时,会自动删除动画
    anim.removedOnCompletion = NO;
    //设置动画最后保持状态
    anim.fillMode = kCAFillModeForwards;
    
    //添加动画对象
    [self.redView.layer addAnimation:anim forKey:nil];

15. CAKeyframeAnimation——关键帧动画

关键帧动画，也是CAPropertyAnimation的子类，与CABasicAnimation的区别是：

  • CABasicAnimation只能从一个数值（fromValue）变到另一个数值（toValue）
  • 而CAKeyframeAnimation会使用一个NSArray保存这些数值

属性说明：

  • values: 上述的NSArray对象。里面的元素称为“关键帧”(keyframe)。动画对象会在指定的时间（duration）内，依次显示values数组中的每一个关键帧
  • path: 代表路径可以设置一个CGPathRef、CGMutablePathRef，让图层按照路径轨迹移动。path只对CALayer的

anchorPoint和position起作用。如果设置了path，那么values将被忽略

  • keyTimes：可以为对应的关键帧指定对应的时间点，其取值范围为0到1.0，keyTimes中的每一个时间值都对应values中的每一帧。如果没有设置keyTimes，各个关键帧的时间是平分的

CABasicAnimation可看做是只有2个关键帧的CAKeyframeAnimation

//    创建动画
  CAKeyframeAnimation *anim = [CAKeyframeAnimation animation];;
//    设置动画对象
//  keyPath决定了执行怎样的动画,调整哪个属性来执行动画
  anim.keyPath = @"position";
  NSValue *v1 = [NSValue valueWithCGPoint:CGPointMake(100, 0)];
  NSValue *v2 = [NSValue valueWithCGPoint:CGPointMake(200, 0)];
  NSValue *v3 = [NSValue valueWithCGPoint:CGPointMake(300, 0)];
  NSValue *v4 = [NSValue valueWithCGPoint:CGPointMake(400, 0)];
  
  anim.values = @[v1,v2,v3,v4];
  anim.duration = 2.0;
//    让图层保持动画执行完毕后的状态
//    状态执行完毕后不要删除动画
  anim.removedOnCompletion = NO;
//    保持最新的状态
  anim.fillMode = kCAFillModeForwards;
  
//    添加动画
  [self.layer addAnimation:anim forKey:nil];
//  根据路径创建动画
//    创建动画
  CAKeyframeAnimation *anim = [CAKeyframeAnimation animation];;

  anim.keyPath = @"position";
  anim.removedOnCompletion = NO;
  anim.fillMode = kCAFillModeForwards;
  anim.duration = 2.0;
  
//    创建一个路径
  CGMutablePathRef path = CGPathCreateMutable();
//    路径的范围
  CGPathAddEllipseInRect(path, NULL, CGRectMake(100, 100, 200, 200));
//    添加路径
  anim.path = path;
//    释放路径(带Create的函数创建的对象都需要手动释放,否则会内存泄露)
  CGPathRelease(path);
//    添加到View的layer
  [self.redView.layer addAnimation:anim forKey];

举个例子：

代码如下：

//帧动画
    CAKeyframeAnimation *anim = [CAKeyframeAnimation animation];
    anim.keyPath = @"transform.rotation";
    anim.values = @[@(angle2Radio(-5)),@(angle2Radio(5)),@(angle2Radio(-5))];
    
    anim.repeatCount = MAXFLOAT;
    
    //自动反转
    //anim.autoreverses = YES;
    
    [self.imageV.layer addAnimation:anim forKey:nil];

再举个例子：

代码如下：


#import "ViewController.h"

@interface ViewController ()

/** 注释*/
@property (nonatomic ,weak) CALayer *fistLayer;

@property (strong, nonatomic)  NSMutableArray *imageArray;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    //设置背景
    self.view.layer.contents = (id)[UIImage imageNamed:@"bg"].CGImage;
    
    CALayer *fistLayer = [CALayer layer];
    fistLayer.frame = CGRectMake(100, 288, 89, 40);
    //fistLayer.backgroundColor = [UIColor redColor].CGColor;
    [self.view.layer addSublayer:fistLayer];
    self.fistLayer = fistLayer;
    
    //fistLayer.transform = CATransform3DMakeRotation(M_PI, 0, 0, 1);
    
    
    //加载图片
    NSMutableArray *imageArray = [NSMutableArray array];
    for (int i = 0; i < 10; i++) {
       UIImage *image = [UIImage imageNamed:[NSString stringWithFormat:@"fish%d",i]];
        [imageArray addObject:image];
    }
    self.imageArray = imageArray;
    //添加定时器
    [NSTimer scheduledTimerWithTimeInterval:0.1 target:self selector:@selector(update) userInfo:nil repeats:YES];
    
    //添加动画
    CAKeyframeAnimation *anim = [CAKeyframeAnimation animation];
    anim.keyPath = @"position";
    

    UIBezierPath *path = [UIBezierPath bezierPath];
    [path moveToPoint:CGPointMake(100, 200)];
    [path addLineToPoint:CGPointMake(350, 200)];
    [path addLineToPoint:CGPointMake(350, 500)];
    [path addQuadCurveToPoint:CGPointMake(100, 200) controlPoint:CGPointMake(150, 700)];
    
    //传入路径
    anim.path = path.CGPath;
    
    anim.duration  = 5;
    
    anim.repeatCount = MAXFLOAT;
    
    anim.calculationMode = @"cubicPaced";
    
    anim.rotationMode = @"autoReverse";
    
    [fistLayer addAnimation:anim forKey:nil];

}

static int _imageIndex = 0;
- (void)update {
    //从数组当中取出图片
    UIImage *image = self.imageArray[_imageIndex];
    self.fistLayer.contents = (id)image.CGImage;
    _imageIndex++;
    if (_imageIndex > 9) {
        _imageIndex = 0;
    }
}

@end

16. 转场动画——CATransition

CATransition是CAAnimation的子类，用于做转场动画，能够为层提供移出屏幕和移入屏幕的动画效果。iOS比Mac OS X的转场动画效果少一点
UINavigationController就是通过CATransition实现了将控制器的视图推入屏幕的动画效果
动画属性:(有的属性是具备方向的,详情看下图)
type：动画过渡类型
subtype：动画过渡方向
startProgress：动画起点(在整体动画的百分比)
endProgress：动画终点(在整体动画的百分比)

    CATransition *anim = [CATransition animation];
    转场类型
    anim.type = @"cube";
    动画执行时间
    anim.duration = 0.5;
    动画执行方向
    anim.subtype = kCATransitionFromLeft;
    添加到View的layer
    [self.redView.layer addAnimation:anim forKey];

举个例子：


#import "ViewController.h"
@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIImageView *imageV;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
 
    self.imageV.userInteractionEnabled = YES;
    //添加手势
    UISwipeGestureRecognizer *leftSwipe = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(swipe:)];
    leftSwipe.direction = UISwipeGestureRecognizerDirectionLeft;
    [self.imageV addGestureRecognizer:leftSwipe];
    
    UISwipeGestureRecognizer *rightSwipe = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(swipe:)];
    
    rightSwipe.direction = UISwipeGestureRecognizerDirectionRight;
    [self.imageV addGestureRecognizer:rightSwipe];
    
}

static int _imageIndex = 0;
- (void)swipe:(UISwipeGestureRecognizer *)swipe {
    
    
    //转场代码与转场动画必须得在同一个方法当中.
    NSString *dir = nil;
    if (swipe.direction == UISwipeGestureRecognizerDirectionLeft) {
        
        _imageIndex++;
        if (_imageIndex > 4) {
            _imageIndex = 0;
        }
        NSString *imageName = [NSString stringWithFormat:@"%d",_imageIndex];
        self.imageV.image = [UIImage imageNamed:imageName];
        
        dir = @"fromRight";
    }else if (swipe.direction == UISwipeGestureRecognizerDirectionRight) {

        _imageIndex--;
        if (_imageIndex < 0) {
            _imageIndex = 4;
        }
        NSString *imageName = [NSString stringWithFormat:@"%d",_imageIndex];
        self.imageV.image = [UIImage imageNamed:imageName];
        
        dir = @"fromLeft";
    }
    
    //添加动画
    CATransition *anim = [CATransition animation];
    //设置转场类型
    anim.type = @"cube";
    //设置转场的方向
    anim.subtype = dir;
    
    anim.duration = 0.5;
    //动画从哪个点开始
    //    anim.startProgress = 0.2;
    //    anim.endProgress = 0.3;
    
    [self.imageV.layer addAnimation:anim forKey:nil];
        
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end

17. CAAnimationGroup——动画组

动画组，是CAAnimation的子类，可以保存一组动画对象，将CAAnimationGroup对象加入层后，组中所有动画对象可以同时并发运行

属性说明：
animations：用来保存一组动画对象的NSArray
默认情况下，一组动画对象是同时运行的，也可以通过设置动画对象的beginTime属性来更改动画的开始时间

    CAAnimationGroup *group = [CAAnimationGroup animation];

//    创建旋转动画对象
    CABasicAnimation *retate = [CABasicAnimation animation];
//    layer的旋转属性
    retate.keyPath = @"transform.rotation";
//    角度
    retate.toValue = @(M_PI);
    
//    创建缩放动画对象
    CABasicAnimation *scale = [CABasicAnimation animation];
//    缩放属性
    scale.keyPath = @"transform.scale";
//    缩放比例
    scale.toValue = @(0.0);
//    添加到动画组当中
    group.animations = @[retate,scale];
//           执行动画时间
    group.duration = 2.0;
//    执行完以后不要删除动画
    group.removedOnCompletion = NO;
//          保持最新的状态
    group.fillMode = kCAFillModeForwards;

    [self.view.layer addAnimation:group forKey:nil];

举个🌰：

CAAnimationGroup.gif

代码如下：

#import "ViewController.h"

@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIView *redView;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    
    //移动
    CABasicAnimation *anim = [CABasicAnimation animation];
    anim.keyPath =  @"position.y";
    anim.toValue = @500;
//    anim.removedOnCompletion = NO;
//    anim.fillMode = kCAFillModeForwards;
//    [self.redView.layer addAnimation:anim forKey:nil];
//    
    //缩放
    CABasicAnimation *anim2 = [CABasicAnimation animation];
    anim2.keyPath =  @"transform.scale";
    anim2.toValue = @0.5;
//    anim2.removedOnCompletion = NO;
//    anim2.fillMode = kCAFillModeForwards;
//    [self.redView.layer addAnimation:anim2 forKey:nil];

    CAAnimationGroup *groupAnim = [CAAnimationGroup animation];
    //会执行数组当中每一个动画对象
    groupAnim.animations = @[anim,anim2];
    groupAnim.removedOnCompletion = NO;
    groupAnim.fillMode = kCAFillModeForwards;
    [self.redView.layer addAnimation:groupAnim forKey:nil];
    
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end

三大动画:(不需要交互的时候可以选择以下动画)
CAAnimationGroup——动画组
CAKeyframeAnimation——关键帧动画
转场动画——CATransition

//参数说明：
 duration：动画的持续时间
 view：需要进行转场动画的视图
 options：转场动画的类型
 animations：将改变视图属性的代码放在这个block中
 completion：动画结束后，会自动调用这个block
 + (void)transitionWithView:(UIView *)view duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion;

使用UIView动画函数实现转场动画——双视图

参数说明：
duration：动画的持续时间
options：转场动画的类型
animations：将改变视图属性的代码放在这个block中
completion：动画结束后，会自动调用这个block

+ (void)transitionFromView:(UIView *)fromView toView:(UIView *)toView duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options completion:(void (^)(BOOL finished))completion;

转场动画
1.创建转场动画:[CATransition animation];
2.设置动画属性值
3.添加到需要专场动画的图层上 [layer addAimation:animation forKer:nil];

转场动画的类型（NSString *type）
fade : 交叉淡化过渡
push : 新视图把旧视图推出去
moveIn: 新视图移到旧视图上面
reveal: 将旧视图移开,显示下面的新视图
cube : 立方体翻滚效果
oglFlip : 上下左右翻转效果
suckEffect : 收缩效果，如一块布被抽走
rippleEffect: 水滴效果
pageCurl : 向上翻页效果
pageUnCurl : 向下翻页效果
cameraIrisHollowOpen : 相机镜头打开效果
cameraIrisHollowClos : 相机镜头关闭效果

注意:\

  • 核心动画只是修改了控件的图形树，换句话说就是只是修改了他的显示，并没有改变控件的真实位置！！！
  • 也就是说在动画的过程中点击控件是不能跟用户进行交互的，切记切记！！！
  • 当然，点击控件的起始位置是可以的。

四、粒子动画

  • CAEmitterLayer 是一个高性能的粒子引擎，被用来创建 实时粒子动画如: 烟雾、火花、雨、雪等等这些效果
  • CAEmitterLayer 常与 CAEmitterCell 结合使用
    • 你将会为不同的例子效果定义一个或多个CAEmitterCell作为模版,
    • 同时CAEmitterLayer负责基于这些模版实例化一个粒子流。
    • 一个CAEmitterCell类似于一个CALayer:
      它有一个contents属性可以定义为一个CGImage，另外还有一些可设置属性控制着表现和行为。

1. CAEmitterLayer

1.1 CAEmitterLayer常用属性

@property(nullable, copy) NSArray<CAEmitterCell *> *emitterCells; // 用来装粒子的数组
@property float birthRate; // 粒子产生系数，默认1.0
@property float lifetime; // 粒子的生命周期系数, 默认1.0
@property CGPoint emitterPosition; // 决定了粒子发射形状的中心点
@property CGFloat emitterZPosition;
@property CGSize emitterSize; // 发射源的尺寸大小
@property CGFloat emitterDepth;
@property(copy) NSString *emitterShape; // 发射源的形状
@property(copy) NSString *emitterMode; // 发射模式
@property(copy) NSString *renderMode; // 渲染模式
@property BOOL preservesDepth;
@property float velocity; // 粒子速度系数, 默认1.0
@property float scale; // 粒子的缩放比例系数, 默认1.0
@property float spin; // 粒子的自旋转速度系数, 默认1.0
@property unsigned int seed; // 随机数发生器

CAEmitterLayer里面的API里面的所有属性都已经贴出来并作了说明，看看注释并调试一下就能理解大部分，接下来重点说说一些常用的属性

  • renderMode：渲染模式，控制着在视觉上粒子图片是如何混合的。 
    NSString * const kCAEmitterLayerUnordered;
NSString * const kCAEmitterLayerOldestFirst;
NSString * const kCAEmitterLayerOldestLast;
NSString * const kCAEmitterLayerBackToFront;
NSString * const kCAEmitterLayerAdditive;
  • emitterMode: 发射模式，这个字段规定了在特定形状上发射的具体形式是什么 
    kCAEmitterLayerPoints： 点模式，发射器是以点的形势发射粒子。
kCAEmitterLayerOutline：这个模式下整个边框都是发射点，即边框进行发射
kCAEmitterLayerSurface：这个模式下是我们边框包含下的区域进行抛洒
kCAEmitterLayerVolume： 同上
  • emitterShape：规定了发射源的形状。 
    kCAEmitterLayerPoint：点形状，发射源的形状就是一个点，位置在上面position设置的位置
kCAEmitterLayerLine：线形状，发射源的形状是一条线，位置在rect的横向的位于垂直方向中间那条
kCAEmitterLayerRectangle：矩形状，发射源是一个矩形，就是上面生成的那个矩形rect
kCAEmitterLayerCuboid：立体矩形形状，发射源是一个立体矩形，这里要生效的话需要设置z方向的数据，如果不设置就同矩形状
kCAEmitterLayerCircle：圆形形状，发射源是一个圆形，形状为矩形包裹的那个圆，二维的
kCAEmitterLayerSphere：立体圆形，三维的圆形，同样需要设置z方向数据，不设置则通二维一样
  • emitterSize：发射源的大小，这个emitterSize结合position构建了发射源的位置及大小的矩形区域rect
  • emitterPosition：发射点的位置。
  • lifetime：粒子的生命周期。
  • velocity：粒子速度。
  • scale：粒子缩放比例。
  • spin：自旋转速度。
  • seed：用于初始化产生的随机数产生的种子。
  • emitterCells：CAEmitterCell对象的数组，被用于把粒子投放到layer上

1.2 CAEmitterLayer决定粒子系数的属性

  • birthRate： 粒子产生系数，默认1.0；每个粒子cell的产生率乘以这个粒子产生系数，得出每一秒产生这个粒子的个数。 即：每秒粒子产生个数 = layer.birthRate * cell.birthRate ；
  • lifetime：粒子的生命周期系数，默认1.0。计算方式同上；
  • velocity：粒子速度系数, 默认1.0。计算方式同上；
  • scale：粒子的缩放比例系数, 默认1.0。计算方式同上；
  • spin：自旋转速度系数, 默认1.0。计算方式同上；

1.3 CAEmitterLayer决定粒子内容的属性

  • emitterCells：用来装粒子的数组。每种粒子就是一个CAEmitterCell。在API中可以看到CAEmitterCell是服从CAMediatiming协议的，可以通过beginTime来控制subCell的出现时机

2. CAEmitterCell

2.1 CAEmitterCell常用属性

@property(nullable, copy) NSString *name; // 粒子名字， 默认为nil
@property(getter=isEnabled) BOOL enabled; 
@property float birthRate; // 粒子的产生率，默认0
@property float lifetime; // 粒子的生命周期,以秒为单位。默认0
@property float lifetimeRange; // 粒子的生命周期的范围，以秒为单位。默认0
@property CGFloat emissionLatitude;// 指定纬度,纬度角代表了在x-z轴平面坐标系中与x轴之间的夹角，默认0: 
@property CGFloat emissionLongitude; // 指定经度,经度角代表了在x-y轴平面坐标系中与x轴之间的夹角，默认0:
@property CGFloat emissionRange; //发射角度范围,默认0，以锥形分布开的发射角度。角度用弧度制。粒子均匀分布在这个锥形范围内;
@property CGFloat velocity; // 速度和速度范围，两者默认0
@property CGFloat velocityRange;
@property CGFloat xAcceleration; // x,y,z方向上的加速度分量,三者默认都是0
@property CGFloat yAcceleration;
@property CGFloat zAcceleration;
@property CGFloat scale; // 缩放比例, 默认是1
@property CGFloat scaleRange; // 缩放比例范围,默认是0
@property CGFloat scaleSpeed; // 在生命周期内的缩放速度,默认是0
@property CGFloat spin; // 粒子的平均旋转速度，默认是0
@property CGFloat spinRange; // 自旋转角度范围，弧度制,默认是0
@property(nullable) CGColorRef color; // 粒子的颜色,默认白色
@property float redRange; // 粒子颜色red,green,blue,alpha能改变的范围,默认0
@property float greenRange;
@property float blueRange;
@property float alphaRange;
@property float redSpeed; // 粒子颜色red,green,blue,alpha在生命周期内的改变速度,默认都是0
@property float greenSpeed;
@property float blueSpeed;
@property float alphaSpeed;
@property(nullable, strong) id contents; // 粒子的内容，为CGImageRef的对象
@property CGRect contentsRect;
@property CGFloat contentsScale;
@property(copy) NSString *minificationFilter;
@property(copy) NSString *magnificationFilter;
@property float minificationFilterBias;
@property(nullable, copy) NSArray<CAEmitterCell *> *emitterCells; // 粒子里面的粒子
@property(nullable, copy) NSDictionary *style;

CAEmitterCell里面的API里面的大部分属性作了说明，看看注释并调试一下就能理解大部分，接下来重点说说一些常用的属性。CAEmitterLayer就是粒子的工厂，但是要实现效果就需要CAEmitterCell的帮助。

  • 粒子在X.Y.Z三个方向上的加速度。 
    @property CGFloat xAcceleration;
@property CGFloat yAcceleration;
@property CGFloat zAcceleration;
  • 粒子缩放比例、缩放范围及缩放速度。（0.0`1.0） 
    @property CGFloat scale;
@property CGFloat scaleRange;
@property CGFloat scaleSpeed;
  • 粒子自旋转速度及范围： 
    @property CGFloat spin;
@property CGFloat spinRange;
  • 粒子RGB及alpha变化范围、速度。 
    //范围：
@property float redRange;
@property float greenRange;
@property float blueRange;
@property float alphaRange;
//速度：
@property float redSpeed;
@property float greenSpeed;
@property float blueSpeed;
@property float alphaSpeed;
  • emitterCells：子粒子。
  • color:指定了一个可以混合图片内容颜色的混合色。
  • birthRate:粒子产生系数，默认1.0.
  • contents：是个CGImageRef的对象,即粒子要展现的图片；
  • emissionRange：值是2π(代码写成M_PI * 2.0f)，这意味着粒子可以从360度任意位置反射出来。如果指定一个小一些的值，就可以创造出一个圆锥形。
  • 指定值在时间线上的变化，例如：alphaSpeed = 0.4，说明粒子每过一秒减小0.4。

2.2 CAEmitterCell决定生命状态的属性

  • lifetime、lifetimeRange：粒子在系统上的生命周期，即存活时间，单位是秒。配合lifetimeRage来让粒子生命周期均匀变化，以便可以让粒子的出现和消失显得更加离散。
  • birthRate：每秒钟产生的粒子的数量，是浮点数。对于这个数量为浮点数，在测试的时候可以灵活使用它。比如你想看粒子的运动状态，但是太多了可能会很迷糊，这时候你把birthRate = 0.1f，其他参数不变，就能看到单个粒子的运动状态。

2.3 CAEmitterCell决定内容的属性

  • contents：为CGImageRef的对象。关于contents会联想到CALayer了，在CALayer中展示静态的图片是需要用到这个属性。提供一张图片，作为粒子系统的粒子。但是因为粒子系统可以给粒子上色，为了做出好的颜色变换效果，通常提供的图片为纯色的图片，一般为白色。
  • name：粒子的名字。初看没什么用，但是当CAEmitterLayer里面有很多个cell的时候，给每个cell设置好名字，要修改一些属性以达到动画效果的改变等，就可以通过KVC拿到这个cell的某个属性。在后面的几个demo中都用用到。

2.4 CAEmitterCell决定颜色状态的属性

粒子系统之所以能做出炫酷的效果，和它的色彩多样化有必不可上的关系，在CAEmitterCell中提供了较多的颜色控制属性这部分属性让你获得了控制粒子颜色，颜色变化范围和速度的能力，你可以凭借它来完成一些渐变的效果或其它构建在它之上的酷炫效果。接下来就看看这些颜色属性。

  • color：color是粒子的颜色属性，这个颜色属性的作用是给粒子上色，它的实现方法很简单，就是将contents自身的颜色的RGBA值 * color的RGBA值，就得到最终的粒子的颜色。为了很好的计算，通常用白色的图片作为contents，因为它的RGB都是255，转换为UIColor中的component就是1，用color乘上它就能得到color设置的颜色效果。
  • redRange、greenRange、blueRange、alphaRange:这些是对应的color的RGBA的取值范围,取值范围为0~1，比如如下设置中
snowCell.color = [[UIColor colorWithRed:0.1 green:0.2 blue:0.3 alpha:0.5]CGColor];
snowCell.redRange = 0.1;
snowCell.greenRange = 0.1;
snowCell.blueRange = 0.1;
snowCell.alphaRange = 0.1;

对应的RGBA的取值范围就是：R（00.2）、G（0.10.3）、B（0.20.4）、A（0.40.6）。

  • redSpeed、greenSpeed、blueSpeed、alphaSpeed:这些是对应的是粒子的RGBA的变化速度，取值范围为0~1。表示每秒钟的RGBA的变化率。这个变化率的计算方式其实很简单，先看下面的几行代码：
snowCell.lifetime = 20.f;  // 粒子的生命周期
snowCell.color = [[UIColor colorWithRed:0.f green:1.f blue:1.f alpha:1.f]CGColor];
snowCell.redSpeed = 0.2;

这里设置了粒子颜色的RGBA，以及redSpeed，其他的没设置默认为0。粒子的生命周期(lifetime)为20秒，那么这个粒子从产生到消失的时间就是20秒。它的Red值为0，redSpeed为0.2，那么在粒子的这个生命周期内，粒子的每秒钟的Rde值就会增加0.2 * 255,表现在外观上的状态就是粒子颜色在不断变化，接近白色。最后粒子生命周期结束的时候，粒子的color正好是RGBA(1,1,1,1)。当然个变化的速度也可以负数，计算方式相同。比如要设置烟花的效果，那么要让在爆炸的过程中颜色变化，就是通过这样的设置达到的效果。

2.5 CAEmitterCell决定飞行轨迹的属性。

CAEmitterLayer虽然控制了粒子的发射位置和形状等，但是粒子的飞行同时也需要自身去决定，比如粒子发射的角度、发散的范围，自转属性等。那么接下来就说说这些属性。

  • emissionLongitude： 指定经度,经度角代表了在x-y轴平面坐标系中与x轴之间的夹角，默认0，弧度制。顺时针方向为正。这样解释看起来不好懂，画个图就明白了。

emissionLatitude

粒子沿着X轴向右飞行，如果`emissionLongtitude = 0`那么粒子会沿着X轴向右飞行，如果想沿着Y轴向下飞行，那么可以设置`emissionLongtitude = M_PI_2`。

  • emissionLatitude:这个和emissionLongitude的原理是一样的，只不过是在三维平面上的x-z轴上与x轴的夹角。

  • emissionRange：发射角度范围,默认0，以锥形分布开的发射角度。角度用弧度制。粒子均匀分布在这个锥形范围内。在二维平面中，若想要以锥形的形式发射粒子，然粒子的发散范围不是一条线，而是一个锥形区域(也可以叫做扇形)，那么可以通过emissionRange来设置一个范围。比如想沿Y轴向下成90度的锥形区域发散，那么可以通过如下代码设置：

snowCell.emissionLongitude = M_PI_2;
snowCell.emissionRange = M_PI_4;

实现的效果如下：

实现效果

可以看到粒子是沿着Y轴向下成90度的一个发散角度。如果想实现火焰等效果。就可以这样，把角度调小一点即可。

  • velocity、velocityRange、xAcceleration 、yAcceleration、zAcceleration:前面两个是粒子的初速度和初速度的范围，后面是三个分别是在x、y、z轴方向的加速度，这个很好理解，初中就应该知道加速度的概念，也就是每秒钟速度的变化量。在放烟花的效果中，烟花飞上天的过程中，模拟一个收重力影响的效果，就可以通过yAcceleration模拟一个重力加速度的效果。
  • spin，spinRange:这两个属性很重要，是粒子的自转属性。在粒子被发射出去之后，想要实现自转，就需要用到他们。**粒子的自转是以弧度制来计算的，表示每秒钟粒子自转的弧度数。spin为正数代表粒子是顺时针旋转的，为负数的话就是逆时针选转了。**举个🌰：粒子的生命周期就是20秒，那么你想让你的粒子这个生命周期内刚好自转12周，若spinRange为0，那么粒子的spin值就应该为((PI/180)*360 * 12)/20，就得到了每秒需要转动的弧度数。

2.6 CAEmitterCell子粒子的属性

  • emitterCells：看到CAEmitterCell的这个属性的时候或许会有些疑惑，不用惊讶，前面说过CAEmitterLayer可以产生cell，通用cell也可以产生cell。那么这个属性就和CAEmitterLayer中的emitterCells一样，也是一个数组。这里有几个需要注意的地方：

    1. 若给cell设置了subCell，若想控制subCell的方向，那么得考虑父cell的方向属性，也就是emissionLongtitude和emissionLatitude这两个属性的情况。

    2. 不管父粒子cell是从什么样的形状上发射出来的，若要发射subCell，subCell总是从kCAEmitterLayerPoint形状上由父粒子的中心发射出来的。

3. 注意

  • CAEmitterLayer 和 CAEmitterCell 中 有相同的属性,他们控制相同的特性
  • 若是相同属性都各自设置了值,粒子发射引擎在工作的时候,会把两个值相乘。作为这个属性的最终值来控制显示效果
  • 相同属性如下: 
    @property float birthRate; // 每秒产生的粒子数量
@property float lifetime; // 粒子的生命周期.单位是秒
@property CGFloat scale; // 粒子的缩放比例

代码示例:

    UIView * containView = [[UIView alloc]initWithFrame:self.view.bounds];
    containView.center = self.view.center;
    containView.backgroundColor = self.view.backgroundColor;
    self.containView = containView;
    [self.view addSubview:self.containView];

    CAEmitterLayer *emitter = [CAEmitterLayer layer];
    emitter.frame = self.containView.bounds;
    [self.containView.layer addSublayer:emitter];
    emitter.renderMode = kCAEmitterLayerAdditive;//这会让重叠的地方变得更亮一些。
    emitter.emitterPosition = CGPointMake(emitter.frame.size.width / 2.0, emitter.frame.size.height / 2.0);

    CAEmitterCell *cell = [[CAEmitterCell alloc] init];
    cell.contents = (__bridge id)[UIImage imageNamed:@"star_yellow"].CGImage;
    cell.birthRate = 150;
    cell.lifetime = 5.0;
    cell.color = [UIColor colorWithRed:1 green:0.5 blue:0.1 alpha:1.0].CGColor;
    cell.alphaSpeed = -0.4;
    cell.velocity = 50;
    cell.velocityRange = 50;
    cell.emissionRange = M_PI * 2.0;

    emitter.emitterCells = @[cell];

案例2:瀑布飘洒效果

- (void)setupSubviews {
    self.layer.backgroundColor = [UIColor blackColor].CGColor;
    // 配置emitter
    [self emiterLayer].renderMode = kCAEmitterLayerAdditive; // 粒子如何混合, 这里是直接重叠
    [self emiterLayer].emitterPosition = CGPointMake(self.frame.size.width, 0); // 发射点的位置
    [self emiterLayer].emitterShape = kCAEmitterLayerPoint;
    

    NSMutableArray * mArr = @[].mutableCopy;
    int cellCount = 6;
    for (int i = 0; i<cellCount; i++) {
        CAEmitterCell * cell = [self getEmitterCellAction];
        [mArr addObject:cell];
    }
    [self emiterLayer].emitterCells = mArr; // 将粒子组成的数组赋值给CAEmitterLayer的emitterCells属性即可.
}

- (CAEmitterCell *)getEmitterCellAction {
    CAEmitterCell *cell = [[CAEmitterCell alloc] init];
    //    cell.contents = (__bridge id)[UIImage imageNamed:@"coin"].CGImage; // 粒子中的图片
    cell.contents = (__bridge id _Nullable)([self setRandomColorCircleImageSize:CGSizeMake(20, 20)].CGImage);
    cell.yAcceleration = arc4random_uniform(80);   // 粒子的初始加速度
    cell.xAcceleration = -cell.yAcceleration-10;
    cell.birthRate = 10.f;           // 每秒生成粒子的个数
    cell.lifetime = 6.f;            // 粒子存活时间
    cell.alphaSpeed = -0.1f;        // 粒子消逝的速度
    cell.velocity = 30.f;           // 粒子运动的速度均值
    cell.velocityRange = 100.f;      // 粒子运动的速度扰动范围
    cell.emissionRange = M_PI; // 粒子发射角度, 这里是一个扇形.
    
//    cell.scale = 0.2;
//    cell.scaleRange = 0.1;
//    cell.scaleSpeed = 0.02;
    
    CGFloat colorChangeValue  = 50.0f;
    cell.blueRange = colorChangeValue;
    cell.redRange =  colorChangeValue;
    cell.greenRange =  colorChangeValue;
    
    return cell;
}

当emitterShape发射源形状取值不同时会有不同效果。

  • kCAEmitterLayerPoint: 点
  • kCAEmitterLayerLine: 线

五、UIImageView帧动画

1.相关的属性和方法:

//动画持续时间
@property (nonatomic) NSTimeInterval animationDuration;         // for one cycle of images. default is number of images * 1/30th of a second (i.e. 30 fps)
//动画持续次数.默认是0,代表无限循环
@property (nonatomic) NSInteger      animationRepeatCount;      // 0 means infinite (default is 0)
//开始动画
- (void)startAnimating;
//结束动画
- (void)stopAnimating;

2.gif动画/图片数组Demo

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{

    NSArray *imageArray = [self getImageArrayWithGIFName:@"aisi"];
    self.imageView.animationImages = imageArray;
    self.imageView.animationDuration = 3;
    self.imageView.animationRepeatCount = MAXFLOAT;
    [self.imageView startAnimating];

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [_imageView stopAnimating];
    });
}

- (NSArray<UIImage *> *)getImageArrayWithGIFName:(NSString *)imageName {

    NSMutableArray *imageArray = [NSMutableArray array];
    NSString *path = [[NSBundle mainBundle] pathForResource:imageName ofType:@"gif"];
    NSData *data = [NSData dataWithContentsOfFile:path];

    if (!data) {
        NSLog(@"图片不存在!");
        return nil;
    }

    CGImageSourceRef source = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
    size_t count = CGImageSourceGetCount(source);

    if (count <= 1) {
        [imageArray addObject:[[UIImage alloc] initWithData:data]];
    }else {

        for (size_t i = 0; i < count; i++) {
            CGImageRef image = CGImageSourceCreateImageAtIndex(source, i, NULL);
            [imageArray addObject:[UIImage imageWithCGImage:image scale:[UIScreen mainScreen].scale orientation:UIImageOrientationUp]];
            CGImageRelease(image);
        }
    }

    CFRelease(source);
    return imageArray;
}

六、经典第三方动画库

  • Lottie
    • 描述: Lottie 是由 Airbnb 开发的一个用于实现高品质动画的库，支持将 Adobe After Effects 制作的动画导出为 JSON 文件，并在 iOS 上进行播放。
    • 特点: 可以轻松实现复杂的矢量动画效果，如路径动画、形状变换等。
    • GitHub 地址: Lottie
  • Spruce iOS
    • 描述: Spruce iOS 是一个用于实现列表项动画的库，可以为 UITableView 和 UICollectionView 添加各种炫酷的列表项过渡效果。
    • 特点: 提供了多种内置的过渡效果，如平行、放大、淡入淡出等，也支持自定义过渡效果。
    • GitHub 地址: Spruce iOS
  • ViewAnimator
    • 描述: ViewAnimator 是一个用于实现视图动画的库，支持为任何视图添加多种动画效果。
    • 特点: 提供了简单易用的 API，支持多种动画效果，如渐变、旋转、弹簧等。
    • GitHub 地址: ViewAnimator】
  • pop动画库介绍
  • 一步一步教你实现iOS音频频谱动画（一）
  • 一步一步教你实现iOS音频频谱动画（二）
  • ......

七、自定义转场动画

1. 核心要点

  • 切换页面转场的几种方式:
    • 通过 UIViewController Modal出一个新VC的页面
    • 通过容器控制器 切换 页面
      • 通过 UINavigationController进行Push或Pop操作,作VC间的页面切换
      • 通过 UITabBarController对 selectIndex 重新赋值，,进行选中VC的切换
  • 转场方式:
    • 默认转场动画: 系统的 Modal、Push或Pop、selectVC切换
    • 自定义转场动画:
      • 交互性(实现动画的实例+手势交互)
      • 非交互形(实现动画的实例)
  • 注意:
    • 系统默认转场动画,是系统提供了默认实现动画实例
    • 因此,我们要自定义转场动画,也要
      • 提供自定义的实现动画实例
      • 在页面转场的时机,将 自定义的实现动画实例 提交 给系统API
        • 系统 通过 Delegate回调方法 把 页面切换的时机告诉我们

因此,接下来我们就要 重点介绍 转场动画 相关的 几个协议(OC、Swift版本的API基本一样.这里用OCAPI介绍)

2. 实现自定义动画对象|UIViewControllerAnimatedTransitioning

实现自定义动画步骤:

    1. 自定义动画对象:
      自定义Class,遵守UIViewControllerAnimatedTransitioning协议
    1. 实现协议中的核心API:
    • 动画执行时间:
      - transitionDuration:transitionContext
    • 动画具体实现
      - animateTransition:
    • 动画执行结束的回调
      - animationEnded:
    1. 在页面转场的时机回调方法中,返回给系统该自定义Class的实例,告诉系统动画实现的细节
  • 协议中的API介绍如下:
@protocol UIViewControllerAnimatedTransitioning <NSObject>
// 设置 转场动画的持续时间
- (NSTimeInterval)transitionDuration:(nullable id <UIViewControllerContextTransitioning>)transitionContext;

/*
 * @ param id <UIViewControllerContextTransitioning> 转场动画的上下文对象
 *    负责 提供 页面切换的上下文,也就是前后两个VC的View等信息
 *    自定义动画的本质,就是编写自定义动画代码,在这个回调中,对前后切换页面的View或layer 添加自定义的动画进行切换
 */
- (void)animateTransition:(id <UIViewControllerContextTransitioning>)transitionContext;

@optional
// 动画结束的 回调
- (void)animationEnded:(BOOL) transitionCompleted;

@end

3. 页面转场上下文对象|UIViewControllerContextTransitioning

  • 协议定义了 在执行自定义转场动画时所需的一些方法和属性
  • 遵守 该协议,并实现了协议中API的 实例对象由系统的回调方法提供
  • 该实例用于提供有关视图控制器之间转场动画的上下文信息（常用属性和方法介绍）:
@protocol UIViewControllerContextTransitioning <NSObject>
// 容器视图，用于容纳转场过程中的View
@property(nonatomic, readonly) UIView *containerView;
...
@property(nonatomic, readonly) BOOL transitionWasCancelled;
...
// 用户标记转场动画是否完成，必须在动画执行完成之后 调用。入参用context实例的transitionWasCancelled属性值的相反值
- (void)completeTransition:(BOOL)didComplete;
// 通过该方法 获取 上下文 切换 的两个FromVC、ToVC
- (nullable __kindof UIViewController *)viewControllerForKey:(UITransitionContextViewControllerKey)key;
// 通过该方法 获取 上下文 切换 的两个FromView、ToView
- (nullable __kindof UIView *)viewForKey:(UITransitionContextViewKey)key API_AVAILABLE(ios(8.0));
...
// 通过该方法 获取 VC 的 最终frame,可以间接获得view的center,size。进行缩放，位移等动画
- (CGRect)finalFrameForViewController:(UIViewController *)vc;
@end

实战示例代码片段:

// This method can only be a no-op if the transition is interactive and not a percentDriven interactive transition.
- (void)animateTransition:(id <UIViewControllerContextTransitioning>)transitionContext{
    self.transitionContext = transitionContext;
    self.containerView = [transitionContext containerView];
    self.fromViewController = [transitionContext viewControllerForKey:UITransitionContextFromViewControllerKey];
    self.toViewController = [transitionContext viewControllerForKey:UITransitionContextToViewControllerKey];
    // iOS8之后才有
    if ([transitionContext respondsToSelector:@selector(viewForKey:)]) {
        self.fromView = [transitionContext viewForKey:UITransitionContextFromViewKey];
        self.toView = [transitionContext viewForKey:UITransitionContextToViewKey];
    } else {
        self.fromView = self.fromViewController.view;
        self.toView = self.toViewController.view;
    }
    
    ...
    self.toView.frame = [self.transitionContext finalFrameForViewController:self.toViewController];
    // 在动画 执行完成的地方要 必须执行的代码:
    BOOL wasCancelled = [self.transitionContext transitionWasCancelled];
    [self.transitionContext completeTransition:!wasCancelled];
    ...
}

4. 自定义Modal转场动画|UIViewControllerTransitioningDelegate

这个协议规定了VC1Modal推出 VC2 和 从VC2 dismiss返回 VC1 的两套接口

  • 交互型
    • Modal推出: - animationControllerForPresentedController: presentingController: sourceController:
    • dismiss返回: - animationControllerForDismissedController:
  • 非交互型(一般添加pan手势进行交互)
    • Modal推出: - interactionControllerForPresentation:
    • dismiss返回: - interactionControllerForDismissal: 
@protocol UIViewControllerTransitioningDelegate <NSObject>

@optional
// 非交互型: 我们直接把我们实现的 自定义动画实例,返回即可「present动画和dismiss动画可相同,也可不同」
- (nullable id <UIViewControllerAnimatedTransitioning>)animationControllerForPresentedController:(UIViewController *)presented presentingController:(UIViewController *)presenting sourceController:(UIViewController *)source;
- (nullable id <UIViewControllerAnimatedTransitioning>)animationControllerForDismissedController:(UIViewController *)dismissed;

// 交互型: 我们要在此提供 实现了 协议`UIViewControllerInteractiveTransitioning`的实例,用于告诉系统,动画的执行进度(这依赖我们 编写的 交互代码,若是用手势交互,则是拖拽的x和参考系x值的百分比...)
- (nullable id <UIViewControllerInteractiveTransitioning>)interactionControllerForPresentation:(id <UIViewControllerAnimatedTransitioning>)animator;
- (nullable id <UIViewControllerInteractiveTransitioning>)interactionControllerForDismissal:(id <UIViewControllerAnimatedTransitioning>)animator;
...
@end

5. 添加交互逻辑|UIViewControllerInteractiveTransitioning

通过 使用 遵守 该协议的 对象,可以获取 开始交互的时机 和 VC页面切换的 上下文对象,进而添加 交互 逻辑,经常用pan手势添加交互逻辑。编写交互逻辑要点如下:

    1. 在回调方法中,获取 开始交互的时机
    1. 给vc的view添加交互逻辑
    1. 根据交互逻辑 计算出 转场 动画 的 百分比,把百分比值percent 提交给 VC页面切换的 上下文对象。以达到,通过交互控制转场动画的效果
    1. 这依然依赖我们实现的自定义转场动画
    1. 我们可以用 继承系统的UIPercentDrivenInteractiveTransition类,专注于编写交互逻辑。并在合适的时机告知系统 动画执行的 情况(百分比进展、取消、结束)
    • - (void)updateInteractiveTransition:(CGFloat)percentComplete;
    • - (void)cancelInteractiveTransition;
    • - (void)finishInteractiveTransition;
@protocol UIViewControllerInteractiveTransitioning <NSObject>
- (void)startInteractiveTransition:(id <UIViewControllerContextTransitioning>)transitionContext;
...
@end

3. UIPercentDrivenInteractiveTransition

@interface UIPercentDrivenInteractiveTransition : NSObject <UIViewControllerInteractiveTransitioning>
@property (readonly) CGFloat duration;
....
// 这三个API底层都是调用 UIViewControllerContextTransitioning 上下文对象中的一样API
- (void)updateInteractiveTransition:(CGFloat)percentComplete;
- (void)cancelInteractiveTransition;
- (void)finishInteractiveTransition;
@end

6. UINavigationController|自定义转场动画

注意区分:

  • VC1 通过UINavigationController push 推出 VC2; 或者 VC2 pop 返回 VC1 ,是在遵守并了协议 UINavigationControllerDelegate的转场动画方法中进行实现
  • 而不是 遵守了 UIViewControllerTransitioningDelegate 协议 的相关方法;
  • 对于 转场 动画的具体实现 和 交互逻辑的具体实现, 是可以一致的。
  • 相关核心API如下:
@protocol UINavigationControllerDelegate <NSObject>
...
// 自定义交互逻辑实现接口
- (nullable id <UIViewControllerInteractiveTransitioning>)navigationController:(UINavigationController *)navigationController
                          interactionControllerForAnimationController:(id <UIViewControllerAnimatedTransitioning>) animationController API_AVAILABLE(ios(7.0));
// 自定义转场动画接口
- (nullable id <UIViewControllerAnimatedTransitioning>)navigationController:(UINavigationController *)navigationController
                                   animationControllerForOperation:(UINavigationControllerOperation)operation
                                                fromViewController:(UIViewController *)fromVC
                                                  toViewController:(UIViewController *)toVC  API_AVAILABLE(ios(7.0));

@end

7. UITabBarController|自定义转场动画

注意区分:

  • UITabBarController select 一个新的 index 进行 页面切换,是在遵守并了协议 UITabBarControllerDelegate的转场动画方法中进行实现
  • 而不是 遵守了 UIViewControllerTransitioningDelegate 协议 的相关方法;
  • 对于 转场 动画的具体实现 和 交互逻辑的具体实现, 是可以一致的。
  • 相关核心API如下:
@protocol UITabBarControllerDelegate <NSObject>
...
// 自定义交互逻辑实现接口
- (nullable id <UIViewControllerInteractiveTransitioning>)tabBarController:(UITabBarController *)tabBarController
                      interactionControllerForAnimationController: (id <UIViewControllerAnimatedTransitioning>)animationController API_AVAILABLE(ios(7.0)) API_UNAVAILABLE(visionos);

// 自定义转场动画接口
- (nullable id <UIViewControllerAnimatedTransitioning>)tabBarController:(UITabBarController *)tabBarController
            animationControllerForTransitionFromViewController:(UIViewController *)fromVC
                                              toViewController:(UIViewController *)toVC  API_AVAILABLE(ios(7.0)) API_UNAVAILABLE(visionos);
@end

8. 推荐阅读

八、动画实战Demo

1. 自定义转场动画Demo

动画的具体实现主要用到UIView的Block动画、CATransition动画; github.com/VanZhang-CN…

2. 粒子动画Demo+CoreAnimation动画+几个layer的实战代码

github.com/VanZhang-CN…

03-iOS 多媒体技术| 图形处理框架-UIKit要点回顾2【UIView、UIViewController、UIWindow、生命周期、事件响应者链等】

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

前言

本篇文章紧接着上一篇文章中图形处理框架-UIKit要点回顾1继续讨论UIKit核心要点:

  • UIView
  • UIViewController
  • UIWindow
  • 事件响应者链

一、UIView

1. UIView 简介

官方对UIView的介绍:

  • UIView是App构建用户界面的基础模块，该类UIView定义所有View公共的行为
  • 它是所有可视化视图内容的基类，可以包含按钮、标签、文本字段、图像等内容，并可以响应用户交互。
  • 以下是 UIView 的一些主要特点和功能：
  • 绘图和布局：
    • UIView 可以在屏幕上绘制内容，并管理其子视图的布局。
    • 通过实现 draw(_:) 方法可以自定义视图的绘制。
    • 使用 subviews 属性可以访问视图的子视图，通过添加、删除、调整子视图的位置和大小来管理布局。
  • 用户交互：
    • UIView 可以响应用户的触摸事件，如单击、双击、长按等。
    • 通过添加手势识别器（UIGestureRecognizer）来识别和处理特定的手势。
    • 通过实现 touchesBegan(_:with:)、touchesMoved(_:with:)、touchesEnded(_:with:) 等方法来处理触摸事件。
  • 视图层级结构：
    • 视图可以嵌套在其他视图中，形成层级结构。
    • 通过调整视图在层级结构中的顺序，可以控制视图的显示顺序和覆盖关系。
  • 动画效果：
    • 使用 UIView 的动画方法（如 animate(withDuration:animations:)）可以实现简单的动画效果，如淡入淡出、移动、缩放等。
  • 视图属性：
    • UIView 具有许多属性，用于控制其外观和行为，如背景颜色、边框、阴影等。
    • 可以通过属性设置来自定义视图的外观和行为，或者通过子类化来创建自定义的视图类型。
  • 自动布局：
    • UIView 支持自动布局（Auto Layout），可以使用约束（Constraints）来描述视图之间的相对位置和大小关系。
    • 自动布局可以适应不同尺寸的屏幕和设备，提供了灵活的界面设计方案。

2. 基本组成部分|属性和方法

typedef NS_ENUM(NSInteger, UISemanticContentAttribute) {
    UISemanticContentAttributeUnspecified = 0,  //!< 未指定，默认值
    UISemanticContentAttributePlayback,         //!< 打开/ RW / FF等播放控制按钮
    UISemanticContentAttributeSpatial,          //!< 控制导致某种形式的定向改变UI中,如分段控制文本对齐方式或在游戏中方向键
    UISemanticContentAttributeForceLeftToRight, //!< 视图总是从左向右布局.
    UISemanticContentAttributeForceRightToLeft  //!< 视图总是从右向左布局.
} NS_ENUM_AVAILABLE_IOS(9_0);

NS_CLASS_AVAILABLE_IOS(2_0) @interface UIView : UIResponder <NSCoding, UIAppearance, UIAppearanceContainer, UIDynamicItem, UITraitEnvironment, UICoordinateSpace, UIFocusItem, CALayerDelegate>
 
/** 返回主layer所使用的类 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(class, nonatomic, readonly) Class layerClass;
#else
+ (Class)layerClass;
#endif
 
/** 通过Frame初始化UI对象 */
- (instancetype)initWithFrame:(CGRect)frame NS_DESIGNATED_INITIALIZER;
/** 用于xib初始化 */
- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder NS_DESIGNATED_INITIALIZER;
 
/** 设置用户交互，默认YES允许用户交互 */
@property(nonatomic,getter=isUserInteractionEnabled) BOOL userInteractionEnabled;
/** 控件标记(父控件可以通过tag找到对应的子控件)，默认为0 */
@property(nonatomic)                                 NSInteger tag;
/** 视图图层(可以用来设置圆角效果/阴影效果) */
@property(nonatomic,readonly,strong)                 CALayer  *layer;
 
/** 返回是否可以成为焦点, 默认NO */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic,readonly) BOOL canBecomeFocused NS_AVAILABLE_IOS(9_0);
#else
- (BOOL)canBecomeFocused NS_AVAILABLE_IOS(9_0);
#endif
/** 是否可以被聚焦 */
@property (readonly, nonatomic, getter=isFocused) BOOL focused NS_AVAILABLE_IOS(9_0);
 
/** 左右滑动翻转效果 */
@property (nonatomic) UISemanticContentAttribute semanticContentAttribute NS_AVAILABLE_IOS(9_0);
 
/** 获取视图的方向 */
+ (UIUserInterfaceLayoutDirection)userInterfaceLayoutDirectionForSemanticContentAttribute:(UISemanticContentAttribute)attribute NS_AVAILABLE_IOS(9_0);
 
/** 获取相对于指定视图的界面方向 */
+ (UIUserInterfaceLayoutDirection)userInterfaceLayoutDirectionForSemanticContentAttribute:(UISemanticContentAttribute)semanticContentAttribute relativeToLayoutDirection:(UIUserInterfaceLayoutDirection)layoutDirection NS_AVAILABLE_IOS(10_0);
 
/** 返回即时内容的布局的方向 */
@property (readonly, nonatomic) UIUserInterfaceLayoutDirection effectiveUserInterfaceLayoutDirection NS_AVAILABLE_IOS(10_0);
 
@end

3. 几何特性相关|frame、bounds、center、transform

/** 自动调整大小方式 */
typedef NS_OPTIONS(NSUInteger, UIViewAutoresizing) {
    UIViewAutoresizingNone                 = 0,     //!< 不自动调整.
    UIViewAutoresizingFlexibleLeftMargin   = 1 << 0,//!< 自动调整与superView左边的距离，保证与superView右边的距离不变.
    UIViewAutoresizingFlexibleWidth        = 1 << 1,//!< 自动调整自己的宽度，保证与superView左边和右边的距离不变.
    UIViewAutoresizingFlexibleRightMargin  = 1 << 2,//!< 自动调整与superView的右边距离，保证与superView左边的距离不变.
    UIViewAutoresizingFlexibleTopMargin    = 1 << 3,//!< 自动调整与superView顶部的距离，保证与superView底部的距离不变.
    UIViewAutoresizingFlexibleHeight       = 1 << 4,//!< 自动调整自己的高度，保证与superView顶部和底部的距离不变.
    UIViewAutoresizingFlexibleBottomMargin = 1 << 5 //!< 自动调整与superView底部的距离，也就是说，与superView顶部的距离不变.
};

@interface UIView(UIViewGeometry)
 
/** 位置和尺寸(以父控件的左上角为坐标原点(0, 0)) */
@property(nonatomic) CGRect            frame;
 
/** 位置和尺寸(以自己的左上角为坐标原点(0, 0)) */
@property(nonatomic) CGRect            bounds;
/** 中心点(以父控件的左上角为坐标原点(0, 0)) */
@property(nonatomic) CGPoint           center;
/** 变形属性(平移\缩放\旋转) */
@property(nonatomic) CGAffineTransform transform;
/** 视图内容的缩放比例 */
@property(nonatomic) CGFloat           contentScaleFactor NS_AVAILABLE_IOS(4_0);
 
/** 是否支持多点触摸，默认NO */
@property(nonatomic,getter=isMultipleTouchEnabled) BOOL multipleTouchEnabled __TVOS_PROHIBITED;
/** 是否独占整个Touch事件，默认NO */
@property(nonatomic,getter=isExclusiveTouch) BOOL       exclusiveTouch __TVOS_PROHIBITED;
 
/** 在指定点上点击测试指定事件 */
- (nullable UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event;
/** 判断当前的点击或者触摸事件的点是否在当前的view中，默认返回YES */
- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event;
 
/** 将像素point由point所在视图转换到目标视图view中，返回在目标视图view中的像素值 */
- (CGPoint)convertPoint:(CGPoint)point toView:(nullable UIView *)view;
/** 将像素point由point所在视图转换到目标视图view中，返回在目标视图view中的像素值 */
- (CGPoint)convertPoint:(CGPoint)point fromView:(nullable UIView *)view;
/** 将rect由rect所在视图转换到目标视图view中，返回在目标视图view中的rect */
- (CGRect)convertRect:(CGRect)rect toView:(nullable UIView *)view;
/** 将rect从view中转换到当前视图中，返回在当前视图中的rect */
- (CGRect)convertRect:(CGRect)rect fromView:(nullable UIView *)view;
 
/** 自动调整子视图尺寸，默认YES则会根据autoresizingMask属性自动调整子视图尺寸 */
@property(nonatomic) BOOL               autoresizesSubviews;
/** 自动调整子视图与父视图的位置，默认UIViewAutoresizingNone */
@property(nonatomic) UIViewAutoresizing autoresizingMask;
 
/** 返回“最佳”大小适合给定的大小 */
- (CGSize)sizeThatFits:(CGSize)size;
/** 调整为刚好合适子视图大小 */
- (void)sizeToFit;
 
@end

4. UIView层级管理|superview、subviews、window

@interface UIView(UIViewHierarchy)
 
/** 获取父视图 */
@property(nullable, nonatomic,readonly) UIView       *superview;
/** 获取所有子视图 */
@property(nonatomic,readonly,copy) NSArray<__kindof UIView *> *subviews;
/** 获取视图所在的Window */
@property(nullable, nonatomic,readonly) UIWindow     *window;
 
/** 从父视图中移除控件 */
- (void)removeFromSuperview;
/** 插入子视图(将子视图插入到subviews数组中index这个位置) */
- (void)insertSubview:(UIView *)view atIndex:(NSInteger)index;
/** 交换subviews数组中所存放子视图的位置 */
- (void)exchangeSubviewAtIndex:(NSInteger)index1 withSubviewAtIndex:(NSInteger)index2;
 
/** 添加子视图(新添加的视图在subviews数组的后面, 显示在最上面) */
- (void)addSubview:(UIView *)view;
/** 插入子视图(将子视图插到siblingSubview之下) */
- (void)insertSubview:(UIView *)view belowSubview:(UIView *)siblingSubview;
/** 插入子视图(将子视图插到siblingSubview之上) */
- (void)insertSubview:(UIView *)view aboveSubview:(UIView *)siblingSubview;
 
/** 将子视图拉到最上面来显示 */
- (void)bringSubviewToFront:(UIView *)view;
/** 将子视图拉到最下面来显示 */
- (void)sendSubviewToBack:(UIView *)view;
 
##pragma mark - 系统自动调用(留给子类去实现)
/** 添加自视图完成后调用 */
- (void)didAddSubview:(UIView *)subview;
/** 将要移除自视图时调用 */
- (void)willRemoveSubview:(UIView *)subview;
 
/** 将要移动到新父视图时调用 */
- (void)willMoveToSuperview:(nullable UIView *)newSuperview;
/** 移动到新父视图完成后调用 */
- (void)didMoveToSuperview;
/** 将要移动到新Window时调用 */
- (void)willMoveToWindow:(nullable UIWindow *)newWindow;
/** 移动到新Window完成后调用 */
- (void)didMoveToWindow;
 
/** 判断view是否为子类 */
- (BOOL)isDescendantOfView:(UIView *)view;
/** 通过tag获得对应的子视图 */
- (nullable __kindof UIView *)viewWithTag:(NSInteger)tag;
 
/** 对现在有布局有调整更改后，使用这个方法进行更新 */
- (void)setNeedsLayout;
/** 强制进行更新layout */
- (void)layoutIfNeeded;
 
/** 控件的frame发生改变的时候就会调用,一般在这里重写布局子控件的位置和尺寸 */
- (void)layoutSubviews;
 
/** 设置view之间的间距，该属性只对autolayout布局有效 */
@property (nonatomic) UIEdgeInsets layoutMargins NS_AVAILABLE_IOS(8_0);
/** 是否将当前视图的间距和父视图相同，默认是NO */
@property (nonatomic) BOOL preservesSuperviewLayoutMargins NS_AVAILABLE_IOS(8_0);
/** 改变view的layoutMargins这个属性时，会触发这个方法 */
- (void)layoutMarginsDidChange NS_AVAILABLE_IOS(8_0);
 
/** 视图间距引导 */
@property(readonly,strong) UILayoutGuide *layoutMarginsGuide NS_AVAILABLE_IOS(9_0);
 
/** 获取此区域的内的布局引导 */
@property (nonatomic, readonly, strong) UILayoutGuide *readableContentGuide  NS_AVAILABLE_IOS(9_0);
@end

5. UIView渲染|裁剪、透明度、自定义绘制

//!< UIView内容填充模式.
typedef NS_ENUM(NSInteger, UIViewContentMode) {
    UIViewContentModeScaleToFill,       //!< 缩放内容到合适比例大小.
    UIViewContentModeScaleAspectFit,    //!< 缩放内容到合适的大小，边界多余部分透明.
    UIViewContentModeScaleAspectFill,   //!< 缩放内容填充到指定大小，边界多余的部分省略.
    UIViewContentModeRedraw,            //!< 重绘视图边界 (需调用 -setNeedsDisplay).
    UIViewContentModeCenter,            //!< 视图保持等比缩放.
    UIViewContentModeTop,               //!< 视图顶部对齐.
    UIViewContentModeBottom,            //!< 视图底部对齐.
    UIViewContentModeLeft,              //!< 视图左侧对齐.
    UIViewContentModeRight,             //!< 视图右侧对齐.
    UIViewContentModeTopLeft,           //!< 视图左上角对齐.
    UIViewContentModeTopRight,          //!< 视图右上角对齐.
    UIViewContentModeBottomLeft,        //!< 视图左下角对齐.
    UIViewContentModeBottomRight,       //!< 视图右下角对齐.
};
 
typedef NS_ENUM(NSInteger, UIViewTintAdjustmentMode) {
    UIViewTintAdjustmentModeAutomatic,  //!< 自动的，与父视图相同.
    
    UIViewTintAdjustmentModeNormal,     //!< 未经修改的.
    UIViewTintAdjustmentModeDimmed,     //!< 饱和、暗淡的原始色.
} NS_ENUM_AVAILABLE_IOS(7_0);

@interface UIView(UIViewRendering)
 
/** 重写drawRect方法，在可以这里进行绘图操作。*/
- (void)drawRect:(CGRect)rect;
 
/** 标记整个视图的边界矩形需要重绘, 调用这个方法会自动调用drawRect方法 */
- (void)setNeedsDisplay;
/** 标记在指定区域内的视图的边界需要重绘, 调用这个方法会自动调用drawRect方法 */
- (void)setNeedsDisplayInRect:(CGRect)rect;
 
/** 是否裁剪超出Bounds范围的子控件，默认NO */
@property(nonatomic)                 BOOL              clipsToBounds;
/** 设置背景颜色，默认nil */
@property(nullable, nonatomic,copy)  UIColor          *backgroundColor UI_APPEARANCE_SELECTOR;
/** 设置透明度(范围0.0~1.0)，默认1.0 */
@property(nonatomic)                 CGFloat           alpha;
/** 设置是否不透明，默认YES不透明 */
@property(nonatomic,getter=isOpaque) BOOL              opaque;
/** 视图重绘前是否先清理以前的内容，默认YES */
@property(nonatomic)                 BOOL              clearsContextBeforeDrawing;
/** 设置是否隐藏，默认NO不隐藏 */
@property(nonatomic,getter=isHidden) BOOL              hidden;
/** 内容显示的模式，默认UIViewContentModeScaleToFill */
@property(nonatomic)                 UIViewContentMode contentMode;
/** 拉伸属性，如图片拉伸 */
@property(nonatomic)                 CGRect            contentStretch NS_DEPRECATED_IOS(3_0,6_0) __TVOS_PROHIBITED;
 
/** 蒙板view */
@property(nullable, nonatomic,strong)          UIView           *maskView NS_AVAILABLE_IOS(8_0);
 
/** 改变应用程序的外观的颜色。默认为nil */
@property(null_resettable, nonatomic, strong) UIColor *tintColor NS_AVAILABLE_IOS(7_0);
 
/** 可以使tintColor变暗，因此整个视图层次变暗 */
@property(nonatomic) UIViewTintAdjustmentMode tintAdjustmentMode NS_AVAILABLE_IOS(7_0);
 
/** 覆盖这个方法的目的是为了当tintColor改变的时候自定义一些行为 */
- (void)tintColorDidChange NS_AVAILABLE_IOS(7_0);
 
@end

6. UIView动画

typedef NS_OPTIONS(NSUInteger, UIViewKeyframeAnimationOptions) {
    UIViewKeyframeAnimationOptionLayoutSubviews            = UIViewAnimationOptionLayoutSubviews, //!< 动画过程中保证子视图跟随运动.
    UIViewKeyframeAnimationOptionAllowUserInteraction      = UIViewAnimationOptionAllowUserInteraction, //!< 动画过程中允许用户交互.
    UIViewKeyframeAnimationOptionBeginFromCurrentState     = UIViewAnimationOptionBeginFromCurrentState, //!< 所有视图从当前状态开始运行.
    UIViewKeyframeAnimationOptionRepeat                    = UIViewAnimationOptionRepeat, //!< 重复运行动画.
    UIViewKeyframeAnimationOptionAutoreverse               = UIViewAnimationOptionAutoreverse, //!< 动画运行到结束点后仍然以动画方式回到初始点.
    UIViewKeyframeAnimationOptionOverrideInheritedDuration = UIViewAnimationOptionOverrideInheritedDuration, //!< 忽略嵌套动画时间设置.
    UIViewKeyframeAnimationOptionOverrideInheritedOptions  = UIViewAnimationOptionOverrideInheritedOptions, //!< 不继承父动画设置或动画类型.
    
    UIViewKeyframeAnimationOptionCalculationModeLinear     = 0 << 10, //!< 连续运算模式, 默认.
    UIViewKeyframeAnimationOptionCalculationModeDiscrete   = 1 << 10, //!< 离散运算模式.
    UIViewKeyframeAnimationOptionCalculationModePaced      = 2 << 10, //!< 均匀执行运算模式.
    UIViewKeyframeAnimationOptionCalculationModeCubic      = 3 << 10, //!< 平滑运算模式.
    UIViewKeyframeAnimationOptionCalculationModeCubicPaced = 4 << 10  //!< 平滑均匀运算模式.
} NS_ENUM_AVAILABLE_IOS(7_0);

/** UIView动画选项 */
typedef NS_OPTIONS(NSUInteger, UIViewAnimationOptions) {
    UIViewAnimationOptionLayoutSubviews            = 1 <<  0, //!< 动画过程中保证子视图跟随运动.
    UIViewAnimationOptionAllowUserInteraction      = 1 <<  1, //!< 动画过程中允许用户交互.
    UIViewAnimationOptionBeginFromCurrentState     = 1 <<  2, //!< 所有视图从当前状态开始运行.
    UIViewAnimationOptionRepeat                    = 1 <<  3, //!< 重复运行动画.
    UIViewAnimationOptionAutoreverse               = 1 <<  4, //!< 动画运行到结束点后仍然以动画方式回到初始点.
    UIViewAnimationOptionOverrideInheritedDuration = 1 <<  5, //!< 忽略嵌套动画时间设置.
    UIViewAnimationOptionOverrideInheritedCurve    = 1 <<  6, //!< 忽略嵌套动画速度设置.
    UIViewAnimationOptionAllowAnimatedContent      = 1 <<  7, //!< 动画过程中重绘视图（注意仅仅适用于转场动画）.
    UIViewAnimationOptionShowHideTransitionViews   = 1 <<  8, //!< 视图切换时直接隐藏旧视图、显示新视图，而不是将旧视图从父视图移除（仅仅适用于转场动画）.
    UIViewAnimationOptionOverrideInheritedOptions  = 1 <<  9, //!< 不继承父动画设置或动画类型.
    
    UIViewAnimationOptionCurveEaseInOut            = 0 << 16, //!< 动画先缓慢，然后逐渐加速.
    UIViewAnimationOptionCurveEaseIn               = 1 << 16, //!< 动画逐渐变慢.
    UIViewAnimationOptionCurveEaseOut              = 2 << 16, //!< 动画逐渐加速.
    UIViewAnimationOptionCurveLinear               = 3 << 16, //!< 动画匀速执行，默认值.
    
    UIViewAnimationOptionTransitionNone            = 0 << 20, //!< 没有转场动画效果.
    UIViewAnimationOptionTransitionFlipFromLeft    = 1 << 20, //!< 从左侧翻转效果.
    UIViewAnimationOptionTransitionFlipFromRight   = 2 << 20, //!< 从右侧翻转效果.
    UIViewAnimationOptionTransitionCurlUp          = 3 << 20, //!< 向后翻页的动画过渡效果.
    UIViewAnimationOptionTransitionCurlDown        = 4 << 20, //!< 向前翻页的动画过渡效果.
    UIViewAnimationOptionTransitionCrossDissolve   = 5 << 20, //!< 旧视图溶解消失显示下一个新视图的效果.
    UIViewAnimationOptionTransitionFlipFromTop     = 6 << 20, //!< 从上方翻转效果.
    UIViewAnimationOptionTransitionFlipFromBottom  = 7 << 20, //!< 从底部翻转效果.
    
    UIViewAnimationOptionPreferredFramesPerSecondDefault     = 0 << 24, //!< 默认的帧每秒.
    UIViewAnimationOptionPreferredFramesPerSecond60          = 3 << 24, //!< 60帧每秒的帧速率.
    UIViewAnimationOptionPreferredFramesPerSecond30          = 7 << 24, //!< 30帧每秒的帧速率.
    
} NS_ENUM_AVAILABLE_IOS(4_0);

/** 动画的曲线枚举 */
typedef NS_ENUM(NSInteger, UIViewAnimationCurve) {
    UIViewAnimationCurveEaseInOut,  //!< 慢进慢出（默认值）.
    UIViewAnimationCurveEaseIn,     //!< 慢进.
    UIViewAnimationCurveEaseOut,    //!< 慢出.
    UIViewAnimationCurveLinear,     //!< 匀速.
};

/** UIView动画过渡效果 */
typedef NS_ENUM(NSInteger, UIViewAnimationTransition) {
    UIViewAnimationTransitionNone,          //!< 无效果.
    UIViewAnimationTransitionFlipFromLeft,  //!< 沿视图垂直中心轴左到右移动.
    UIViewAnimationTransitionFlipFromRight, //!< 沿视图垂直中心轴右到左移动.
    UIViewAnimationTransitionCurlUp,        //!< 由底部向上卷起.
    UIViewAnimationTransitionCurlDown,      //!< 由顶部向下展开.
};

@interface UIView(UIViewAnimation)
 
/** 开始动画 */
+ (void)beginAnimations:(nullable NSString *)animationID context:(nullable void *)context;
/** 提交动画 */
+ (void)commitAnimations;
 
/** 设置动画代理, 默认nil */
+ (void)setAnimationDelegate:(nullable id)delegate;
/** 动画将要开始时执行方法（必须要先设置动画代理）, 默认NULL */
+ (void)setAnimationWillStartSelector:(nullable SEL)selector;
/** 动画已结束时执行方法（必须要先设置动画代理）, 默认NULL */
+ (void)setAnimationDidStopSelector:(nullable SEL)selector;
/** 设置动画时长, 默认0.2秒 */
+ (void)setAnimationDuration:(NSTimeInterval)duration;
/** 动画延迟执行时间, 默认0.0秒 */
+ (void)setAnimationDelay:(NSTimeInterval)delay;
/** 设置在动画块内部动画属性改变的开始时间, 默认now ([NSDate date]) */
+ (void)setAnimationStartDate:(NSDate *)startDate;
/** 设置动画曲线, 默认UIViewAnimationCurveEaseInOut */
+ (void)setAnimationCurve:(UIViewAnimationCurve)curve;
/** 动画的重复播放次数， 默认0 */
+ (void)setAnimationRepeatCount:(float)repeatCount;
/** 设置是否自定翻转当前的动画效果, 默认NO */
+ (void)setAnimationRepeatAutoreverses:(BOOL)repeatAutoreverses;
/** 设置动画从当前状态开始播放, 默认NO */
+ (void)setAnimationBeginsFromCurrentState:(BOOL)fromCurrentState;
 
/** 在动画块中为视图设置过渡动画 */
+ (void)setAnimationTransition:(UIViewAnimationTransition)transition forView:(UIView *)view cache:(BOOL)cache;
 
/** 设置是否激活动画 */
+ (void)setAnimationsEnabled:(BOOL)enabled;
/** 返回一个布尔值表示动画是否结束 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(class, nonatomic, readonly) BOOL areAnimationsEnabled;
#else
+ (BOOL)areAnimationsEnabled;
#endif
/** 先检查动画当前是否启用，然后禁止动画，执行block内的方法，最后重新启用动画，而且这个方法不会阻塞基于CoreAnimation的动画 */
+ (void)performWithoutAnimation:(void (NS_NOESCAPE ^)(void))actionsWithoutAnimation NS_AVAILABLE_IOS(7_0);
 
/** 当前动画的持续时间 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(class, nonatomic, readonly) NSTimeInterval inheritedAnimationDuration NS_AVAILABLE_IOS(9_0);
#else
+ (NSTimeInterval)inheritedAnimationDuration NS_AVAILABLE_IOS(9_0);
#endif
 
@end
 
@interface UIView(UIViewAnimationWithBlocks)
 
/** 用于对一个或多个视图的改变的持续时间、延时、选项动画完成时的操作 */
+ (void)animateWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);
 
/** 用于对一个或多个视图的改变的持续时间、选项动画完成时的操作，默认：delay = 0.0, options = 0 */
+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);
 
/** 用于对一个或多个视图的改变的持续时间内动画完成时的操作，默认：delay = 0.0, options = 0, completion = NULL */
+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations NS_AVAILABLE_IOS(4_0);
 
/** 使用与物理弹簧运动相对应的定时曲线执行视图动画 */
+ (void)animateWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay usingSpringWithDamping:(CGFloat)dampingRatio initialSpringVelocity:(CGFloat)velocity options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(7_0);
 
/** 为指定的容器视图创建转换动画 */
+ (void)transitionWithView:(UIView *)view duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^ __nullable)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);
 
/** 使用给定的参数在指定视图之间创建转换动画 */
+ (void)transitionFromView:(UIView *)fromView toView:(UIView *)toView duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(4_0); // toView added to fromView.superview, fromView removed from its superview
 
/** 在一个或多个视图上执行指定的系统提供的动画，以及定义的可选并行动画 */
+ (void)performSystemAnimation:(UISystemAnimation)animation onViews:(NSArray<__kindof UIView *> *)views options:(UIViewAnimationOptions)options animations:(void (^ __nullable)(void))parallelAnimations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(7_0);
 
@end
 
/** UIView的关键帧动画 */
@interface UIView (UIViewKeyframeAnimations)
 
/** 创建一个动画块对象，可用于为当前视图设置基于关键帧的动画 */
+ (void)animateKeyframesWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay options:(UIViewKeyframeAnimationOptions)options animations:(void (^)(void))animations completion:(void (^ __nullable)(BOOL finished))completion NS_AVAILABLE_IOS(7_0);
/** 添加指定开始时间、持续时间的关键帧动画(起始和持续时间是0.0和1.0之间的值) */
+ (void)addKeyframeWithRelativeStartTime:(double)frameStartTime relativeDuration:(double)frameDuration animations:(void (^)(void))animations NS_AVAILABLE_IOS(7_0);
 
@end

7. UIView手势处理


@interface UIView (UIViewGestureRecognizers)
 
/** 当前视图所附加的所有手势识别器 */
@property(nullable, nonatomic,copy) NSArray<__kindof UIGestureRecognizer *> *gestureRecognizers NS_AVAILABLE_IOS(3_2); 
/** 添加一个手势识别器 */
- (void)addGestureRecognizer:(UIGestureRecognizer*)gestureRecognizer NS_AVAILABLE_IOS(3_2);
/** 移除一个手势识别器 */
- (void)removeGestureRecognizer:(UIGestureRecognizer*)gestureRecognizer NS_AVAILABLE_IOS(3_2);
/** 开始一个手势识别器 */
- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer NS_AVAILABLE_IOS(6_0);
@end

8. UIView的生命周期相关的API

UIView生命周期相关函数:

//构造方法,初始化时调用,不会调用init方法
- (instancetype)initWithFrame:(CGRect)frame;
//添加子控件时调用
- (void)didAddSubview:(UIView *)subview ;
//构造方法,内部会调用initWithFrame方法
- (instancetype)init;
//xib归档初始化视图后调用,如果xib中添加了子控件会在didAddSubview方法调用后调用
- (instancetype)initWithCoder:(NSCoder *)aDecoder;
//唤醒xib,可以布局子控件
- (void)awakeFromNib;
//父视图将要更改为指定的父视图,当前视图被添加到父视图时调用
- (void)willMoveToSuperview:(UIView *)newSuperview;
//父视图已更改
- (void)didMoveToSuperview;
//其窗口对象将要更改
- (void)willMoveToWindow:(UIWindow *)newWindow;
//窗口对象已经更改
- (void)didMoveToWindow;
//布局子控件
- (void)layoutSubviews;
//绘制视图
- (void)drawRect:(CGRect)rect;
//从父控件中移除
- (void)removeFromSuperview;
//销毁
- (void)dealloc;
//将要移除子控件
- (void)willRemoveSubview:(UIView *)subview;

8.1 没有子控件的UIView

显示过程：

//(superview)
- (void)willMoveToSuperview:(nullable UIView *)newSuperview
- (void)didMoveToSuperview

//(window)
- (void)willMoveToWindow:(nullable UIWindow *)newWindow
- (void)didMoveToWindow

- (void)layoutSubviews

移出过程：

//(window)
- (void)willMoveToWindow:(nullable UIWindow *)newWindow
- (void)didMoveToWindow

//(superview)
- (void)willMoveToSuperview:(nullable UIView *)newSuperview
- (void)didMoveToSuperview

- (void)removeFromSuperview
- (void)dealloc

但是在移出时newWindow和newSuperview 都是nil。

8.2 包含子控件的UIView

  • 当增加一个子控件时，就会执行 didAddSubview,之后也会执行一次layoutSubview。
  • 在view释放后,执行完,dealloc就会多次执行willRemoveSubview.先add的view，先释放掉。

8.3 layoutSubview

在上面的方法中，经常发现layoutSubview会被调用，下面说下layoutSubview的调用情况:

  • 1、addSubview会触发layoutSubviews，如果addSubview 如果连续2个 只会执行一次，具体原因下面说。
  • 2、设置view的Frame会触发layoutSubviews，必须是frame的值设置前后发生了变化。
  • 3、滚动一个UIScrollView会触发layoutSubviews。
  • 4、旋转Screen会触发父UIView上的layoutSubviews事件。
  • 5、改变一个UIView大小的时候也会触发父UIView上的layoutSubviews事件。

TIP

  • 1、如果要立即执行layoutSubview
    • 要先调用[view setNeedsLayout]，把标记设为需要布局.
    • 然后马上调用[view layoutIfNeeded]，实现布局.

    其中的原理是：执行setNeedsLayout后会在receiver标上一个需要被重新布局的标记，在系统runloop的下一个周期自动调用layoutSubviews。
    这样刷新会产生延迟，所以我们需要马上执行layoutIfNeeded。就会开始遍历Subviews的链，判断该receiver是否需要layout。如果需要立即执行layoutSubview

  • 2、addSubview
    • 每一个视图只能有唯一的一个父视图。如果当前操作视图已经有另外的一个父视图，则addSubview的操作会把它先从上一个父视图中移除（包括响应者链），再加到新的父视图上面。
    • 连续2次的addSubview，只会执行一次layoutsubview。因为一次的runLoop结束后，如果有需要刷新，执行一次即可。

9. UIView屏幕快照

#pragma mark - View快照
@interface UIView (UISnapshotting)
/** 将当前显示的view截取成一个新的view */
- (nullable UIView *)snapshotViewAfterScreenUpdates:(BOOL)afterUpdates NS_AVAILABLE_IOS(7_0);
/** 缩放一个view默认是从中心点进行缩放的 */
- (nullable UIView *)resizableSnapshotViewFromRect:(CGRect)rect afterScreenUpdates:(BOOL)afterUpdates withCapInsets:(UIEdgeInsets)capInsets NS_AVAILABLE_IOS(7_0);
/** 屏幕快照 */
- (BOOL)drawViewHierarchyInRect:(CGRect)rect afterScreenUpdates:(BOOL)afterUpdates NS_AVAILABLE_IOS(7_0);
@end

10. UIView其它特性

//
//  UIView.h
//
//  Created by VanZhang on 2017/5/22.
//  Copyright © 2017年 . All rights reserved.
//
//  详解 UIResponder.h
//  Version iOS 10.3
//
 
#import <Foundation/Foundation.h>
#import <QuartzCore/QuartzCore.h>
#import <UIKit/UIResponder.h>
#import <UIKit/UIInterface.h>
#import <UIKit/UIKitDefines.h>
#import <UIKit/UIAppearance.h>
#import <UIKit/UIDynamicBehavior.h>
#import <UIKit/NSLayoutConstraint.h>
#import <UIKit/UITraitCollection.h>
#import <UIKit/UIFocus.h>
 
NS_ASSUME_NONNULL_BEGIN
 
 
typedef NS_ENUM(NSUInteger, UISystemAnimation) {
    UISystemAnimationDelete,    //!< 系统删除动画
} NS_ENUM_AVAILABLE_IOS(7_0);
 
@protocol UICoordinateSpace <NSObject>
 
/** 将像素point由point所在视图转换到目标视图view中，返回在目标视图view中的像素值 */
- (CGPoint)convertPoint:(CGPoint)point toCoordinateSpace:(id <UICoordinateSpace>)coordinateSpace NS_AVAILABLE_IOS(8_0);
/** 将像素point由point所在视图转换到目标视图view中，返回在目标视图view中的像素值 */
- (CGPoint)convertPoint:(CGPoint)point fromCoordinateSpace:(id <UICoordinateSpace>)coordinateSpace NS_AVAILABLE_IOS(8_0);
/** 将rect由rect所在视图转换到目标视图view中，返回在目标视图view中的rect */
- (CGRect)convertRect:(CGRect)rect toCoordinateSpace:(id <UICoordinateSpace>)coordinateSpace NS_AVAILABLE_IOS(8_0);
/** 将rect从view中转换到当前视图中，返回在当前视图中的rect */
- (CGRect)convertRect:(CGRect)rect fromCoordinateSpace:(id <UICoordinateSpace>)coordinateSpace NS_AVAILABLE_IOS(8_0);
 
/** 获取bounds */
@property (readonly, nonatomic) CGRect bounds NS_AVAILABLE_IOS(8_0);
 
@end
 
@class UIBezierPath, UIEvent, UIWindow, UIViewController, UIColor, UIGestureRecognizer, UIMotionEffect, CALayer, UILayoutGuide;
 

 
 
@interface UIView (UIViewMotionEffects)
 
/** 添加运动效果，当倾斜设备时视图稍微改变其位置 */
- (void)addMotionEffect:(UIMotionEffect *)effect NS_AVAILABLE_IOS(7_0);
 
/** 移除运动效果 */
- (void)removeMotionEffect:(UIMotionEffect *)effect NS_AVAILABLE_IOS(7_0);
 
/** 所有添加的运动效果 */
@property (copy, nonatomic) NSArray<__kindof UIMotionEffect *> *motionEffects NS_AVAILABLE_IOS(7_0);
 
@end
 
 
 
#pragma mark - View状态保存恢复
@interface UIView (UIStateRestoration)
/** 标示是否支持保存,恢复视图状态信息 */
@property (nullable, nonatomic, copy) NSString *restorationIdentifier NS_AVAILABLE_IOS(6_0);
/** 保存视图状态相关的信息 */
- (void) encodeRestorableStateWithCoder:(NSCoder *)coder NS_AVAILABLE_IOS(6_0);
/** 恢复和保持视图状态相关信息 */
- (void) decodeRestorableStateWithCoder:(NSCoder *)coder NS_AVAILABLE_IOS(6_0);
@end
 

 
NS_ASSUME_NONNULL_END

11. UIView自动布局相关


typedef NS_ENUM(NSInteger, UILayoutConstraintAxis) {
    UILayoutConstraintAxisHorizontal = 0,   //!< 水平约束.
    UILayoutConstraintAxisVertical = 1      //!< 竖直约束.
};
 
 
@interface UIView (UIConstraintBasedLayoutInstallingConstraints)
 
/** 获取所有约束 */
@property(nonatomic,readonly) NSArray<__kindof NSLayoutConstraint *> *constraints NS_AVAILABLE_IOS(6_0);
 
/** 添加一个约束 */
- (void)addConstraint:(NSLayoutConstraint *)constraint NS_AVAILABLE_IOS(6_0);
/** 添加多个约束 */
- (void)addConstraints:(NSArray<__kindof NSLayoutConstraint *> *)constraints NS_AVAILABLE_IOS(6_0);
/** 移除一个约束 */
- (void)removeConstraint:(NSLayoutConstraint *)constraint NS_AVAILABLE_IOS(6_0);
/** 移除多个约束 */
- (void)removeConstraints:(NSArray<__kindof NSLayoutConstraint *> *)constraints NS_AVAILABLE_IOS(6_0);
@end
 
 
@interface UIView (UIConstraintBasedLayoutCoreMethods)
/** 更新视图和其子视图的约束 */
- (void)updateConstraintsIfNeeded NS_AVAILABLE_IOS(6_0);
/** 为视图更新约束，可以重写这个方法来设置当前view局部的布局约束 */
- (void)updateConstraints NS_AVAILABLE_IOS(6_0) NS_REQUIRES_SUPER;
/** 视图的约束是否需要更新 */
- (BOOL)needsUpdateConstraints NS_AVAILABLE_IOS(6_0);
/** 设置视图的约束需要更新，调用这个方法，系统会调用updateConstraints去更新布局 */
- (void)setNeedsUpdateConstraints NS_AVAILABLE_IOS(6_0);
@end
 
 
@interface UIView (UIConstraintBasedCompatibility)
 
/** 是否启用自动布局约束，默认YES. IB默认是NO */
@property(nonatomic) BOOL translatesAutoresizingMaskIntoConstraints NS_AVAILABLE_IOS(6_0);
 
/** 是否使用约束布局 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(class, nonatomic, readonly) BOOL requiresConstraintBasedLayout NS_AVAILABLE_IOS(6_0);
#else
+ (BOOL)requiresConstraintBasedLayout NS_AVAILABLE_IOS(6_0);
#endif
 
@end
 
 
@interface UIView (UIConstraintBasedLayoutLayering)
 
/** 返回给定框架的视图的对齐矩阵 */
- (CGRect)alignmentRectForFrame:(CGRect)frame NS_AVAILABLE_IOS(6_0);
/** 返回给定对齐矩形的视图的frame */
- (CGRect)frameForAlignmentRect:(CGRect)alignmentRect NS_AVAILABLE_IOS(6_0);
 
/** 返回从视图的frame上定义的对齐矩阵的边框 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic, readonly) UIEdgeInsets alignmentRectInsets NS_AVAILABLE_IOS(6_0);
#else
- (UIEdgeInsets)alignmentRectInsets NS_AVAILABLE_IOS(6_0);
#endif
 
/** 返回满足基线约束条件的视图 */
- (UIView *)viewForBaselineLayout NS_DEPRECATED_IOS(6_0, 9_0, "Override -viewForFirstBaselineLayout or -viewForLastBaselineLayout as appropriate, instead") __TVOS_PROHIBITED;
 
/** 返回用于满足第一基线约束的视图 */
@property(readonly,strong) UIView *viewForFirstBaselineLayout NS_AVAILABLE_IOS(9_0);
 
/** 返回用于满足上次基线约束的视图 */
@property(readonly,strong) UIView *viewForLastBaselineLayout NS_AVAILABLE_IOS(9_0);
 
 
UIKIT_EXTERN const CGFloat UIViewNoIntrinsicMetric NS_AVAILABLE_IOS(6_0); // -1
/** 返回接收对象的原本大小 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic, readonly) CGSize intrinsicContentSize NS_AVAILABLE_IOS(6_0);
#else
- (CGSize)intrinsicContentSize NS_AVAILABLE_IOS(6_0);
#endif
/** 废除视图原本内容的size */
- (void)invalidateIntrinsicContentSize NS_AVAILABLE_IOS(6_0);
 
/** 设置当视图要变大时，视图的压缩改变方式，返回一个优先权（确定view有多大的优先级阻止自己变大） */
- (UILayoutPriority)contentHuggingPriorityForAxis:(UILayoutConstraintAxis)axis NS_AVAILABLE_IOS(6_0);
/** 设置放先权 */
- (void)setContentHuggingPriority:(UILayoutPriority)priority forAxis:(UILayoutConstraintAxis)axis NS_AVAILABLE_IOS(6_0);
 
/** 设置当视图要变小时，视图的压缩改变方式，是水平缩小还是垂直缩小，并返回一个优先权（确定有多大的优先级阻止自己变小） */
- (UILayoutPriority)contentCompressionResistancePriorityForAxis:(UILayoutConstraintAxis)axis NS_AVAILABLE_IOS(6_0);
/** 设置优先权 */
- (void)setContentCompressionResistancePriority:(UILayoutPriority)priority forAxis:(UILayoutConstraintAxis)axis NS_AVAILABLE_IOS(6_0);
@end
 
// Size To Fit
 
UIKIT_EXTERN const CGSize UILayoutFittingCompressedSize NS_AVAILABLE_IOS(6_0);
UIKIT_EXTERN const CGSize UILayoutFittingExpandedSize NS_AVAILABLE_IOS(6_0);
 
@interface UIView (UIConstraintBasedLayoutFittingSize)
/** 返回满足持有约束的视图的size */
- (CGSize)systemLayoutSizeFittingSize:(CGSize)targetSize NS_AVAILABLE_IOS(6_0);
/** 返回满足它所包含的约束的视图的大小 */
- (CGSize)systemLayoutSizeFittingSize:(CGSize)targetSize withHorizontalFittingPriority:(UILayoutPriority)horizontalFittingPriority verticalFittingPriority:(UILayoutPriority)verticalFittingPriority NS_AVAILABLE_IOS(8_0);
@end
 
@interface UIView (UILayoutGuideSupport)
 
/** 此视图拥有布局向导对象的数组 */
@property(nonatomic,readonly,copy) NSArray<__kindof UILayoutGuide *> *layoutGuides NS_AVAILABLE_IOS(9_0);
 
/** 向视图中添加布局向导 */
- (void)addLayoutGuide:(UILayoutGuide *)layoutGuide NS_AVAILABLE_IOS(9_0);
 
/** 向视图中添加布局向导 */
- (void)removeLayoutGuide:(UILayoutGuide *)layoutGuide NS_AVAILABLE_IOS(9_0);
@end
 
@class NSLayoutXAxisAnchor,NSLayoutYAxisAnchor,NSLayoutDimension;
@interface UIView (UIViewLayoutConstraintCreation)
/** 布局视图的前缘框的布局锚点 */
@property(readonly, strong) NSLayoutXAxisAnchor *leadingAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的后缘边框的布局锚点 */
@property(readonly, strong) NSLayoutXAxisAnchor *trailingAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的左边框的布局锚点 */
@property(readonly, strong) NSLayoutXAxisAnchor *leftAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的右边框的布局锚点 */
@property(readonly, strong) NSLayoutXAxisAnchor *rightAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的顶边框的布局锚点 */
@property(readonly, strong) NSLayoutYAxisAnchor *topAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的底边框的布局锚点 */
@property(readonly, strong) NSLayoutYAxisAnchor *bottomAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的宽度 */
@property(readonly, strong) NSLayoutDimension *widthAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的高度 */
@property(readonly, strong) NSLayoutDimension *heightAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的水平中心轴 */
@property(readonly, strong) NSLayoutXAxisAnchor *centerXAnchor NS_AVAILABLE_IOS(9_0);
/** 布局视图的垂直中心轴 */
@property(readonly, strong) NSLayoutYAxisAnchor *centerYAnchor NS_AVAILABLE_IOS(9_0);
/** 一个代表对视图中的文本的最高线基线布置锚 */
@property(readonly, strong) NSLayoutYAxisAnchor *firstBaselineAnchor NS_AVAILABLE_IOS(9_0);
/** 一个代表对视图中的文本的最低线基线布置锚 */
@property(readonly, strong) NSLayoutYAxisAnchor *lastBaselineAnchor NS_AVAILABLE_IOS(9_0);
 
@end
 
@interface UIView (UIConstraintBasedLayoutDebugging)
 
/** 获得实体在不同方向上所有的布局约束 */
- (NSArray<__kindof NSLayoutConstraint *> *)constraintsAffectingLayoutForAxis:(UILayoutConstraintAxis)axis NS_AVAILABLE_IOS(6_0);
 
/** 可以知道当前视图的布局是否会有歧义 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic, readonly) BOOL hasAmbiguousLayout NS_AVAILABLE_IOS(6_0);
#else
- (BOOL)hasAmbiguousLayout NS_AVAILABLE_IOS(6_0);
#endif
 
/** 这个方法会随机改变视图的layout到另外一个有效的layout。这样我们就可以很清楚的看到哪一个layout导致了整体的布局约束出现了错误，或者我们应该增加更多的布局约束 */
- (void)exerciseAmbiguityInLayout NS_AVAILABLE_IOS(6_0);
@end
 
/** 约束调试，只在DEBUG环境下被调用 */
@interface UILayoutGuide (UIConstraintBasedLayoutDebugging)
 
/** 获得实体在不同方向上所有的布局约束 */
- (NSArray<__kindof NSLayoutConstraint *> *)constraintsAffectingLayoutForAxis:(UILayoutConstraintAxis)axis NS_AVAILABLE_IOS(10_0);
 
/** 可以知道当前视图的布局是否会有歧义 */
#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic, readonly) BOOL hasAmbiguousLayout NS_AVAILABLE_IOS(10_0);
#else
- (BOOL)hasAmbiguousLayout NS_AVAILABLE_IOS(10_0);
#endif
@end

12. View的常用派生类简介

UIView派生系

  • UIControl:
    UIControl 主要负责管理用户的触摸事件，并根据用户的操作来更新自身的状态。
  • UIScrollView:
    用于展示可滚动内容的滚动视图控件，支持滚动、缩放、滚动事件处理等功能。
  • UILabel:
    用于显示文本内容的标签控件，支持文字的自动换行、字体、颜色等属性设置。
  • UIImageView:
    用于显示图像的图像视图控件，支持显示本地图像和远程图像，并可以设置内容模式、动画效果等。
  • UIProgressView:
    用于显示进度的进度条控件，支持水平或垂直方向的显示、进度值设置和动画效果。
  • UIActivityIndicatorView:
    用于显示加载指示器的活动指示器控件，支持显示和隐藏、动画效果等。
  • UIPickerView:
    用于选择器的选择器视图控件，支持显示多列数据、滚动选择、事件处理等功能。
  • UIStackView:
    用于自动布局的栈视图控件，支持水平或垂直方向的排列、子视图的布局等功能。

UIControl派生系

  • UIButton:
    用于响应用户点击事件的按钮控件，支持不同状态下的不同外观样式和事件处理。
  • UITextField:
    用于输入文本内容的文本输入框控件，支持单行或多行输入、键盘类型设置、占位符文本等。
  • UISwitch:
    用于切换开关状态的开关控件，支持显示开关状态、切换动画等。
  • UISlider:
    用于选择连续数值的滑块控件，支持滑块的最小值、最大值、当前值设置和事件处理。
  • UIDatePicker:
    用于选择日期和时间的日期选择器控件，支持显示日期和时间、滚动选择、事件处理等功能。

UIScrollView派生系

  • UITextView:
    用于显示和编辑多行文本内容的文本视图控件，支持显示富文本、滚动、编辑等功能。
  • UITableView:
    用于展示列表数据的表格视图控件，支持单列或多列列表、分组、滚动、数据源和代理等功能。
  • UICollectionView:
    用于展示多列数据的集合视图控件，支持自定义布局、分区和单元格、数据源和代理等功能。

二、UIViewController

1. UIViewController的职责

官方对UIViewController的介绍:
UIViewController用于管理App视图结构层次的对象,它的主要职责如下:

  • 提供了丰富的生命周期方法和事件处理机制
    • 管理生命周期:
      提供生命周期方法，包括视图加载、显示、隐藏、销毁等阶段
    • 事件处理机制:
      • UIResponder中的几种事件:
        • UIViewController 是由 UIResponder 派生的,因此 UIResponder负责处理的几种事件,UIViewController中同样有效:
          包括:触摸事件、按压事件、加速事件、远程控制事件、键盘事件等。
          回顾了解可以参照这篇文章的UIResponder部分
      • 响应系统事件:负责响应系统事件，包括:
        • 设备方向变化
        • 内存警告
        • 视图控制器切换等
      • 其它事件:
        手势事件等
  • 负责 管理 UIKit 应用程序的视图层次结构的对象
    • 通过VC的生命周期方法,负责处理UI的加载、显示、布局、交互、旋转、隐藏和卸载等任务
    • 实现容器视图控制器(在接下来的篇幅介绍相关API)
  • 页面切换:
    • 通过容器控制器（UINavigationController、UITabBarController）来管理界面之间的切换和导航
    • 通过 URLRouter(URL+OpenURL+容器控制器 配合) 进行页面切换
  • 页面传值:
    可以通过属性、委托、通知、Block回调(闭包回调)、路由跳转传参等方式进行数据传递和通信
  • ...

2. UIViewController|生命周期相关 API

我们先介绍 UIViewController生命周期相关的API:

  1. loadView():
    • 简介:用于创建或加载视图控制器的视图层次结构。
    • 说明:如果视图控制器通过storyboard创建，通常不需要重写这个方法。
  2. viewDidLoad():
    • 简介:视图已经加载完成，此时可以进行一些初始化操作，如添加子视图、设置视图的初始状态等。
  3. viewWillAppear(_ animated: Bool):
    • 简介:视图即将显示在屏幕上，此时视图控制器可以做一些在界面显示之前需要准备的工作，比如更新数据。
    • 参数:animated表示视图是否以动画形式显示。
  4. viewDidAppear(_ animated: Bool):
    • 简介:视图已经显示在屏幕上，此时可以执行一些需要在界面显示完成后立即执行的操作，比如启动定时器。
    • 参数:animated表示视图是否以动画形式显示。
  5. viewWillDisappear(_ animated: Bool):
    • 简介:视图即将从屏幕上消失，此时可以做一些在界面消失之前需要处理的工作，比如保存数据。
    • 参数:animated表示视图是否以动画形式消失。
  6. viewDidDisappear(_ animated: Bool):
    • 简介:视图已经从屏幕上消失，此时可以执行一些需要在界面消失后立即执行的操作，比如停止定时器。
    • 参数:animated表示视图是否以动画形式消失。
  7. viewWillLayoutSubviews():
    • 简介:视图将要布局子视图时调用，可以在此方法中更新子视图的布局。
  8. viewDidLayoutSubviews():
    • 简介:视图已经布局子视图完成时调用，可以在此方法中执行一些与子视图布局相关的操作。

2.1 重写生命周期方法

我们重写UIViewController生命周期方法,以便于后面Demo实践:

#pragma mark- 对象 初始化 和 销毁
+ (void)initialize {
    NSLog(@"========   类初始化方法： initialize   =======\n");
}

- (instancetype)init {
     self = [super init];
    NSLog(@"========   实例初始化方法： init   =======\n");
    return self;
}

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
    self = [super initWithCoder:aDecoder];
    NSLog(@"========   从归档初始化：  initWithCoder:(NSCoder *)aDecoder   =======\n");
    return self;
}

- (void)dealloc {
    NSLog(@"========   释放： dealloc   =======\n");
}

#pragma mark- 系统事件|内存警告
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    NSLog(@"========   收到内存警告： didReceiveMemoryWarning   =======\n");
}

#pragma mark- life cycle
- (void)loadView {
    [super loadView];
    NSLog(@"========   加载视图： loadView   =======\n");
}

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor orangeColor];
    NSLog(@"========   将要加载视图： viewDidLoad   =======\n");
}

- (void)viewWillLayoutSubviews {
    [super viewWillLayoutSubviews];
    NSLog(@"========   将要布局子视图： viewWillLayoutSubviews   =======\n");
}

- (void)viewDidLayoutSubviews {
    [super viewDidLayoutSubviews];
    NSLog(@"========   已经布局子视图： viewDidLayoutSubviews   =======\n");
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    NSLog(@"========   视图将要出现： viewWillAppear:(BOOL)animated   =======\n");
}

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];
    NSLog(@"========   视图已经出现： viewDidAppear:(BOOL)animated   =======\n");
}

- (void)viewWillDisappear:(BOOL)animated {
    [super viewWillDisappear:animated];
    NSLog(@"========   视图将要消失： viewWillDisappear:(BOOL)animated   =======\n");
}

- (void)viewDidDisappear:(BOOL)animated {
    [super viewDidDisappear:animated];
    NSLog(@"========   视图已经消失： viewDidDisappear:(BOOL)animated   =======\n");
}

2.2 单ViewController|生命周期事件

我们创建Demo工程:

  • 将重写 UIViewController生命周期相关方法 和 类 初始化 和 反初始化 相关的方法 插入ViewController
  • 然后我们启动工程,观察VC的生命周期事件的执行情况。

控制台打印结果:

========   类初始化方法： initialize   =======
========   实例初始化方法： init   =======
========   加载视图： loadView   =======
========   将要加载视图： viewDidLoad   =======
========   视图将要出现： viewWillAppear:(BOOL)animated   =======
========   将要布局子视图： viewWillLayoutSubviews   =======
========   已经布局子视图： viewDidLayoutSubviews   =======
========   视图已经出现： viewDidAppear:(BOOL)animated   =======
========   视图将要消失： viewWillDisappear:(BOOL)animated   =======
========   视图已经消失： viewDidDisappear:(BOOL)animated   =======
========   释放： dealloc   =======

ViewController生命周期方法执行顺序:

  • (push页面阶段开始)initialize —> init
    • —> loadView —> viewDidLoad
    • —> viewWillAppear
      • —> viewWillLayoutSubviews
      • —> viewDidLayoutSubviews
    • —> viewDidAppear
    • (pop页面阶段开始)—> viewWillDisappear
    • —> viewDidDisappear
  • —> dealloc

2.3 VC1 push VC2|VC的生命周期事件

  • 创建两个VC(FirstViewController、SecondViewController)
  • 将重写 UIViewController生命周期相关方法 和 类 初始化 和 反初始化 相关的方法 分别插入FirstViewController、SecondViewController
  • 编写代码,由FirstViewControllerpush打开SecondViewController
  • 然后我们启动工程,观察SecondViewController的生命周期事件的执行情况。

控制台打印结果:

======== SecondViewController   类初始化方法： initialize   =======
======== SecondViewController   实例初始化方法： init   =======
======== SecondViewController   加载视图： loadView   =======
======== SecondViewController   将要加载视图： viewDidLoad   =======
======== FirstViewController   视图将要消失： viewWillDisappear:(BOOL)animated   =======
======== SecondViewController   视图将要出现： viewWillAppear:(BOOL)animated   =======
======== SecondViewController   将要布局子视图： viewWillLayoutSubviews   =======
======== SecondViewController   已经布局子视图： viewDidLayoutSubviews   =======
======== FirstViewController   视图已经消失： viewDidDisappear:(BOOL)animated   =======
======== SecondViewController   视图已经出现： viewDidAppear:(BOOL)animated   =======
======== SecondViewController   视图将要消失： viewWillDisappear:(BOOL)animated   =======
======== FirstViewController   视图将要出现： viewWillAppear:(BOOL)animated   =======
======== SecondViewController   视图已经消失： viewDidDisappear:(BOOL)animated   =======
======== FirstViewController   视图已经出现： viewDidAppear:(BOOL)animated   =======
======== SecondViewController   释放： dealloc   =======

SecondViewController生命周期方法执行顺序:

  • (push页面阶段开始)initialize —> init
    • —> loadView
    • —> viewDidLoad
      • —> FirstViewController viewWillDisappear
    • —> viewWillAppear
      • —> viewWillLayoutSubviews
      • —> viewDidLayoutSubviews
      • —> FirstViewController viewDidDisappear
    • —> viewDidAppear
    • (pop页面阶段开始)—> viewWillDisappear
      • —> FirstViewController viewWillAppear
    • —> viewDidDisappear
      • —> FirstViewController viewDidAppear
  • —> dealloc Tips,以上执行情况,没有标注 FirstViewController的均为 SecondViewController在执行工作

3. UIViewController|容器控制器相关API

在iOS5的时候为了解耦、更加清晰的处理页面View的逻辑，UIViewController提供了addChildViewController方法，将ViewController作为容器处理视图控制器的切换，将比较复杂的UI使用子ViewController来管理。

我们在一个页面要以菜单分类的形式展示不同菜单下的内容，且每个菜单下的内容UI构成不相同时,可以把每个菜单的内容放到单独一个VC去管理。由一个主VC作为容器处理视图控制器管理展示，

相关属性和方法介绍:

///子视图控制器数组
@property(nonatomic,readonly) NSArray *childViewControllers

///向父VC中添加子VC
- (void)addChildViewController:(UIViewController *)childController

///将子VC从父VC中移除
- (void) removeFromParentViewController

///fromViewController 当前显示在父视图控制器中的子视图控制器
///toViewController 将要显示的姿势图控制器
///duration 动画时间
/// options 动画效果(渐变,从下往上等等,具体查看API)
///animations 转换过程中得动画
///completion 转换完成
- (void)transitionFromViewController:(UIViewController *)fromViewController toViewController:(UIViewController *)toViewController duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^ __nullable)(void))animations completion:(void (^ __nullable)(BOOL finished))completion

///当向父VC添加子VC之后，该方法会自动调用;
- (void)willMoveToParentViewController:(UIViewController *)parent

///从父VC移除子VC之后，该方法会自动调用
- (void)didMoveToParentViewController:(UIViewController *)parent

4. UIViewController|几种初始化方式

这一块相对简单,我们列举一下就好:

    1. 纯代码创建:
      在代码中使用UIViewController的init(nibName:bundle:)或者init()方法创建视图控制器，并设置相应的属性。
    let viewController = MyViewController()
    1. Storyboard创建:
      在Storyboard中创建UIViewController，并设置对应的类名。
    let storyboard = UIStoryboard(name: "Main", bundle: nil)
let viewController = storyboard.instantiateViewController(withIdentifier: "MyViewController") as! MyViewController
    1. XIB文件创建:
      在XIB文件中创建UIViewController，并设置对应的类名。
    let viewController = MyViewController(nibName: "MyViewController", bundle: nil)
    1. 使用UIStoryboard的instantiateInitialViewController方法:
      用于从Storyboard中实例化初始化的视图控制器。
    let storyboard = UIStoryboard(name: "Main", bundle: nil)
let initialViewController = storyboard.instantiateInitialViewController() as! MyViewController
    1. 自定义初始化方法:
      有时候视图控制器可能有一些自定义的初始化方法，可以根据需要进行调用。
    let viewController = MyViewController(customParameter: parameter)

5. UIViewController|几种页面传值方式

这一块相对简单,我们列举一下就好:

正向传值:

  • 初始化方法 传值
  • 属性 传值

逆向传值:

  • Delegate
  • 回调闭包Block/Closure

可逆向传值也可正向传值的几种方式

  • 全局单例 传值
  • 通知广播 传值
  • 模块管理工具模块间通讯EventBus,事件管理派发 传值
  • 跳转路由 传值(本质还是属性传值)

6. UIViewController|几种页面跳转方式

这一块相对简单,我们列举一下就好:

  1. Segue跳转:
    在Storyboard中通过Segue连接不同的视图控制器，在跳转时会执行Segue的相关代码。 
        // 使用performSegue(withIdentifier:sender:)方法手动执行Segue跳转
    performSegue(withIdentifier: "SegueIdentifier", sender: self)

    // 准备跳转前的准备工作
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "SegueIdentifier" {
            // 根据segue.destination获取目标视图控制器
            let destinationVC = segue.destination as! DestinationViewController
            // 设置目标视图控制器的属性等
        }
    }
  2. Modal方式跳转:
    以模态形式显示目标视图控制器，覆盖在当前视图控制器之上。 
    // 以模态形式显示目标视图控制器
present(destinationVC, animated: true, completion: nil)

// 关闭模态视图控制器返回到上一个视图控制器
dismiss(animated: true, completion: nil)
  3. 通过容器控制器管理:
    • a. Navigation Controller:
      使用Navigation Controller管理多个视图控制器的堆栈，通过push和pop操作实现页面跳转
    // 在Navigation Controller中推入目标视图控制器
navigationController?.pushViewController(destinationVC, animated: true)

// 返回上一个视图控制器
navigationController?.popViewController(animated: true)

// 返回到根视图控制器
navigationController?.popToRootViewController(animated: true)

    • b. Tab Bar Controller:
      使用Tab Bar Controller管理多个视图控制器，通过Tab Bar切换不同的视图控制器。

      // 通过Tab Bar切换到指定的视图控制器
tabBarController?.selectedIndex = index

    • c. UIViewController自定义容器控制器:
      自定义容器视图控制器，管理多个子视图控制器，并通过代码控制子视图控制器的显示和隐藏。

      // 添加子视图控制器
addChild(destinationVC)
view.addSubview(destinationVC.view)
destinationVC.didMove(toParent: self)

// 移除子视图控制器
destinationVC.willMove(toParent: nil)
destinationVC.view.removeFromSuperview()
destinationVC.removeFromParent()

7. UIViewController|自定义转场动画

本文先介绍一下自定义转场动画的核心要点,对具体动画的实现等,在后面介绍动画相关章节的时候,会有更详尽的分享。

7.1 核心要点

  • 切换页面转场的几种方式:
    • 通过 UIViewController Modal出一个新VC的页面
    • 通过容器控制器 切换 页面
      • 通过 UINavigationController进行Push或Pop操作,作VC间的页面切换
      • 通过 UITabBarController对 selectIndex 重新赋值，,进行选中VC的切换
  • 转场方式:
    • 默认转场动画: 系统的 Modal、Push或Pop、selectVC切换
    • 自定义转场动画:
      • 交互性(实现动画的实例+手势交互)
      • 非交互形(实现动画的实例)
  • 注意:
    • 系统默认转场动画,是系统提供了默认实现动画实例
    • 因此,我们要自定义转场动画,也要
      • 提供自定义的实现动画实例
      • 在页面转场的时机,将 自定义的实现动画实例 提交 给系统API
        • 系统 通过 Delegate回调方法 把 页面切换的时机告诉我们

因此,接下来我们就要 重点介绍 转场动画 相关的 几个协议(OC、Swift版本的API基本一样.这里用OCAPI介绍)

7.2 实现自定义动画对象|UIViewControllerAnimatedTransitioning

实现自定义动画步骤:

    1. 自定义动画对象:
      自定义Class,遵守UIViewControllerAnimatedTransitioning协议
    1. 实现协议中的核心API:
    • 动画执行时间:
      - transitionDuration:transitionContext
    • 动画具体实现
      - animateTransition:
    • 动画执行结束的回调
      - animationEnded:
    1. 在页面转场的时机回调方法中,返回给系统该自定义Class的实例,告诉系统动画实现的细节
  • 协议中的API介绍如下:
@protocol UIViewControllerAnimatedTransitioning <NSObject>
// 设置 转场动画的持续时间
- (NSTimeInterval)transitionDuration:(nullable id <UIViewControllerContextTransitioning>)transitionContext;

/*
 * @ param id <UIViewControllerContextTransitioning> 转场动画的上下文对象
 *    负责 提供 页面切换的上下文,也就是前后两个VC的View等信息
 *    自定义动画的本质,就是编写自定义动画代码,在这个回调中,对前后切换页面的View或layer 添加自定义的动画进行切换
 */
- (void)animateTransition:(id <UIViewControllerContextTransitioning>)transitionContext;

@optional
// 动画结束的 回调
- (void)animationEnded:(BOOL) transitionCompleted;

@end

7.3 页面转场上下文对象|UIViewControllerContextTransitioning

  • 协议定义了 在执行自定义转场动画时所需的一些方法和属性
  • 遵守 该协议,并实现了协议中API的 实例对象由系统的回调方法提供
  • 该实例用于提供有关视图控制器之间转场动画的上下文信息（常用属性和方法介绍）:
@protocol UIViewControllerContextTransitioning <NSObject>
// 容器视图，用于容纳转场过程中的View
@property(nonatomic, readonly) UIView *containerView;
...
@property(nonatomic, readonly) BOOL transitionWasCancelled;
...
// 用户标记转场动画是否完成，必须在动画执行完成之后 调用。入参用context实例的transitionWasCancelled属性值的相反值
- (void)completeTransition:(BOOL)didComplete;
// 通过该方法 获取 上下文 切换 的两个FromVC、ToVC
- (nullable __kindof UIViewController *)viewControllerForKey:(UITransitionContextViewControllerKey)key;
// 通过该方法 获取 上下文 切换 的两个FromView、ToView
- (nullable __kindof UIView *)viewForKey:(UITransitionContextViewKey)key API_AVAILABLE(ios(8.0));
...
// 通过该方法 获取 VC 的 最终frame,可以间接获得view的center,size。进行缩放，位移等动画
- (CGRect)finalFrameForViewController:(UIViewController *)vc;
@end

实战示例代码片段:

// This method can only be a no-op if the transition is interactive and not a percentDriven interactive transition.
- (void)animateTransition:(id <UIViewControllerContextTransitioning>)transitionContext{
    self.transitionContext = transitionContext;
    self.containerView = [transitionContext containerView];
    self.fromViewController = [transitionContext viewControllerForKey:UITransitionContextFromViewControllerKey];
    self.toViewController = [transitionContext viewControllerForKey:UITransitionContextToViewControllerKey];
    // iOS8之后才有
    if ([transitionContext respondsToSelector:@selector(viewForKey:)]) {
        self.fromView = [transitionContext viewForKey:UITransitionContextFromViewKey];
        self.toView = [transitionContext viewForKey:UITransitionContextToViewKey];
    } else {
        self.fromView = self.fromViewController.view;
        self.toView = self.toViewController.view;
    }
    
    ...
    self.toView.frame = [self.transitionContext finalFrameForViewController:self.toViewController];
    // 在动画 执行完成的地方要 必须执行的代码:
    BOOL wasCancelled = [self.transitionContext transitionWasCancelled];
    [self.transitionContext completeTransition:!wasCancelled];
    ...
}

7.4 自定义Modal转场动画|UIViewControllerTransitioningDelegate

这个协议规定了VC1Modal推出 VC2 和 从VC2 dismiss返回 VC1 的两套接口

  • 交互型
    • Modal推出: - animationControllerForPresentedController: presentingController: sourceController:
    • dismiss返回: - animationControllerForDismissedController:
  • 非交互型(一般添加pan手势进行交互)
    • Modal推出: - interactionControllerForPresentation:
    • dismiss返回: - interactionControllerForDismissal: 
@protocol UIViewControllerTransitioningDelegate <NSObject>

@optional
// 非交互型: 我们直接把我们实现的 自定义动画实例,返回即可「present动画和dismiss动画可相同,也可不同」
- (nullable id <UIViewControllerAnimatedTransitioning>)animationControllerForPresentedController:(UIViewController *)presented presentingController:(UIViewController *)presenting sourceController:(UIViewController *)source;
- (nullable id <UIViewControllerAnimatedTransitioning>)animationControllerForDismissedController:(UIViewController *)dismissed;

// 交互型: 我们要在此提供 实现了 协议`UIViewControllerInteractiveTransitioning`的实例,用于告诉系统,动画的执行进度(这依赖我们 编写的 交互代码,若是用手势交互,则是拖拽的x和参考系x值的百分比...)
- (nullable id <UIViewControllerInteractiveTransitioning>)interactionControllerForPresentation:(id <UIViewControllerAnimatedTransitioning>)animator;
- (nullable id <UIViewControllerInteractiveTransitioning>)interactionControllerForDismissal:(id <UIViewControllerAnimatedTransitioning>)animator;
...
@end

7.5 添加交互逻辑|UIViewControllerInteractiveTransitioning

通过 使用 遵守 该协议的 对象,可以获取 开始交互的时机 和 VC页面切换的 上下文对象,进而添加 交互 逻辑,经常用pan手势添加交互逻辑。编写交互逻辑要点如下:

    1. 在回调方法中,获取 开始交互的时机
    1. 给vc的view添加交互逻辑
    1. 根据交互逻辑 计算出 转场 动画 的 百分比,把百分比值percent 提交给 VC页面切换的 上下文对象。以达到,通过交互控制转场动画的效果
    1. 这依然依赖我们实现的自定义转场动画
    1. 我们可以用 继承系统的UIPercentDrivenInteractiveTransition类,专注于编写交互逻辑。并在合适的时机告知系统 动画执行的 情况(百分比进展、取消、结束)
    • - (void)updateInteractiveTransition:(CGFloat)percentComplete;
    • - (void)cancelInteractiveTransition;
    • - (void)finishInteractiveTransition;
@protocol UIViewControllerInteractiveTransitioning <NSObject>
- (void)startInteractiveTransition:(id <UIViewControllerContextTransitioning>)transitionContext;
...
@end

3. UIPercentDrivenInteractiveTransition

@interface UIPercentDrivenInteractiveTransition : NSObject <UIViewControllerInteractiveTransitioning>
@property (readonly) CGFloat duration;
....
// 这三个API底层都是调用 UIViewControllerContextTransitioning 上下文对象中的一样API
- (void)updateInteractiveTransition:(CGFloat)percentComplete;
- (void)cancelInteractiveTransition;
- (void)finishInteractiveTransition;
@end

7.6 UINavigationController|自定义转场动画

注意区分:

  • VC1 通过UINavigationController push 推出 VC2; 或者 VC2 pop 返回 VC1 ,是在遵守并了协议 UINavigationControllerDelegate的转场动画方法中进行实现
  • 而不是 遵守了 UIViewControllerTransitioningDelegate 协议 的相关方法;
  • 对于 转场 动画的具体实现 和 交互逻辑的具体实现, 是可以一致的。
  • 相关核心API如下:
@protocol UINavigationControllerDelegate <NSObject>
...
// 自定义交互逻辑实现接口
- (nullable id <UIViewControllerInteractiveTransitioning>)navigationController:(UINavigationController *)navigationController
                          interactionControllerForAnimationController:(id <UIViewControllerAnimatedTransitioning>) animationController API_AVAILABLE(ios(7.0));
// 自定义转场动画接口
- (nullable id <UIViewControllerAnimatedTransitioning>)navigationController:(UINavigationController *)navigationController
                                   animationControllerForOperation:(UINavigationControllerOperation)operation
                                                fromViewController:(UIViewController *)fromVC
                                                  toViewController:(UIViewController *)toVC  API_AVAILABLE(ios(7.0));

@end

7.7 UITabBarController|自定义转场动画

注意区分:

  • UITabBarController select 一个新的 index 进行 页面切换,是在遵守并了协议 UITabBarControllerDelegate的转场动画方法中进行实现
  • 而不是 遵守了 UIViewControllerTransitioningDelegate 协议 的相关方法;
  • 对于 转场 动画的具体实现 和 交互逻辑的具体实现, 是可以一致的。
  • 相关核心API如下:
@protocol UITabBarControllerDelegate <NSObject>
...
// 自定义交互逻辑实现接口
- (nullable id <UIViewControllerInteractiveTransitioning>)tabBarController:(UITabBarController *)tabBarController
                      interactionControllerForAnimationController: (id <UIViewControllerAnimatedTransitioning>)animationController API_AVAILABLE(ios(7.0)) API_UNAVAILABLE(visionos);

// 自定义转场动画接口
- (nullable id <UIViewControllerAnimatedTransitioning>)tabBarController:(UITabBarController *)tabBarController
            animationControllerForTransitionFromViewController:(UIViewController *)fromVC
                                              toViewController:(UIViewController *)toVC  API_AVAILABLE(ios(7.0)) API_UNAVAILABLE(visionos);
@end

8. 自定义地转场动画的实战

对于转场动画的具体实战,我们在 总结 iOS中的动画实现 的 文章 再进一步 展开讲述。此处 仅是 讲解转场动画实现的基础

三、UIWindow

1. UIWindow核心要点

简介

官网对 UIWindow 的介绍:

The backdrop for your app’s user interface and the object that dispatches events to your views.

我们用将官网的介绍用中文解释:

  • UIWindow是应用程序用户界面的背景
  • UIWindow负责派发各类事件给视图对象Views

UIWindow核心要点

这样的介绍显然太过简洁难懂,我们结合多年的项目实施经验给予更详细的诠释:

  1. 作用:
    • 每个应用程序都 至少有一个UIWindow 对象，它是应用程序中的主窗口。
    • UIWindow是应用程序中视图层次结构的顶层容器，它负责管理应用程序中所有视图的显示和布局。
  2. 层级关系:
    • UIWindow对象位于视图层次结构的最顶层，所有其他视图都是它的子视图或子视图的子视图。
  3. 创建方式:
    • 可以通过UIWindow类的init(frame:)方法或init(windowScene:)方法来创建一个窗口对象。
    • 通常情况下，UIWindow对象是由系统自动创建并管理的，开发者无需手动创建。
  4. 关键属性:
    • rootViewController：窗口的根视图控制器，决定了窗口中显示的内容。
    • windowScene：窗口所属的场景对象，用于多窗口管理。
  5. 常用方法:
    • makeKeyAndVisible()：将窗口设置为主窗口,并显示在屏幕上。
    • resignKey()：将窗口从主窗口中移除。
  6. 事件处理:
    • UIWindow对象是响应者链中的一部分，可以处理触摸事件、运动事件等。
    • 通常情况下，UIWindow对象会将触摸事件传递给其子视图或根视图控制器进行处理。
  7. 窗口管理:
    • iOS应用程序可以包含多个窗口，每个窗口可以显示不同的内容。
    • 多窗口管理通常用于支持多任务处理、多屏幕显示等功能。
  8. 使用场景:
    • UIWindow通常用于显示应用程序的主界面、弹出窗口、警告框等。
    • 也可以用于实现一些特殊效果，如悬浮按钮、悬浮窗口等。
  1. 其它:
    • iOS程序启动完毕后，创建的第一个视图控件就是UIWindow
      • 接着创建控制器的View
      • 最后将控制器的View添加到UIWindow上，于是控制器的View就显示在屏幕上了
    • 状态栏和键盘是特殊的UIWindow

那么UIWindow是如何将View显示到屏幕上的呢？

  • 这里有三个重要的对象 UIScreen，UIWindow，UIView
  • UIScreen 对象识别物理屏幕连接到设备
  • UIWindow 对象提供绘画支持给屏幕
  • UIView 执行绘画，当窗口要显示内容的时候，UIView 绘画出他们的内容并附加到窗口上。

2. UIWindow的创建

2.1 UIWindow是什么时候创建的?

当我们新建一个项目，直接在stroyboard为view设置一个背景颜色，然后运行项目，就能看到换了背景颜色的view，这说明系统已经帮我们创建了一个UIWindow，那么这个UIWindow是什么时候创建的？

我们找到程序的入口main函数，来看程序的启动过程

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

此时我们可以根据UIApplicationMain函数了解程序启动的过程

  1. 根据传递的类名创建UIApplication对象，这是第一个对象
  2. 创建UIApplication代理对象，并给UIApplicaiton对象设置代理
  3. 开启 主运行循环 main events loop处理事件，保持程序一直运行
  4. 加载info.plist,判断是否指定mian(xib 或者 storyboard)如果指定就去加载

当我们把指定的Main Interface 中mian给删除的时候，重新运行程序，就会发现我们之前设置的view没有办法显示了。

Main Interface 中 Main删除

此时我们基本可以想到，UIWindow应该是在加载storyboard的时候系统创建的，那么系统是如何加载storyboard的呢？
系统在加载storyboard的时候会做以下三件事情:

    1. 创建窗口
    1. 加载mian.storyboard 并实例化view controller
    1. 分配新视图控制器到窗口root viewcontroller,然后使窗口显在示屏幕上。

因此，当系统加载完info.plist，判断后发现没有main，就不会加载storyboard，也就不会帮我们创建UIWindow，那么我们需要自己在程序启动完成的时候也就是在didFinishLaunchingWithOptions方法中创建。

2.2 如何创建UIWindow?

首先根据系统加载storyboard时做的三件事情，我们可以总结出UIWindow创建步骤

    1. 创建窗口对象
    1. 创建窗口的根控制器，并且赋值
    1. 显示窗口

并且我们在AppDelegate.h中发现属性window

@property (strong, nonatomic) UIWindow *window;

那么我们来看一下如何创建UIWindow

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    //创建窗口对象
    self.window = [[UIWindow alloc]initWithFrame:[UIScreen mainScreen].bounds];
    //创建窗口的根控制器，并且赋值
    UIViewController *rootVc = [[UIViewController alloc]init];
    self.window.rootViewController = rootVc;
    //显示窗口
    [self.window makeKeyAndVisible];
    return YES;
}

窗口显示注意点:

    1. 我们看到系统为我们创建的window属性是strong强引用，是为了不让窗口销毁，所以需要强引用
    1. 窗口的尺寸必须设置，一般设置为屏幕大小。
    1. [self.window addSubview:rootVc.view];
    • 可直接将控制器的view添加到UIWindow中，并不理会它对应的控制器
    • 但是这种方法违背了MVC原则，当我们需要处理一些业务逻辑的时候就很麻烦了。
    • 当发生屏幕旋转事件的时候
      • UIApplication对象会将旋转事件传递给 UIWindow
      • UIWindow又会将旋转事件传递给它的根控制器,由根控制器决定是否需要旋转
      • UIApplication对象 -> UIWindow -> 根控制器。
        （[self.window addSubview:rootVc.view];没有设置根控制器，所以不能跟着旋转）。
    1. 设置根控制器可以将对应界面的事情交给对应的控制器去管理。

makeKeyAndVisible的底层实现

那么[self.window makeKeyAndVisible];这个方法为什么就能显示窗口呢？我们来看一下[self.window makeKeyAndVisible];的底层实现了哪些功能：

当我们不调用这个方法，打印self.window。

UIWindow: 0x7f920503cc80; frame = (0 0; 414 736); hidden = YES; gestureRecognizers = ; layer = >

我们可以看到 hidden = YES;那么hidden = NO就可以显示窗口了
另外，我们在[self.window makeKeyAndVisible];前后分别输出一下application.keyWindow

NSLog(@"%@",application.keyWindow);
[self.window makeKeyAndVisible];
NSLog(@"%@",application.keyWindow);

打印内容

UIWindow[6259:1268399] (null)
UIWindow[6259:1268399] ; layer = >

我们可以看到调用[self.window makeKeyAndVisible];方法之后application.keyWindow就有值了，那么[self.window makeKeyAndVisible];的底层实现就很明显了。

  1. 可以显示窗口 self.window.hidden = NO;
  2. 成为应用程序的主窗口 application.keyWindow = self.window，这个会报错，因为application.keyWindow是readonly，所以我们没有办法直接赋值。

2.3 通过storyboard加载控制器

刚才我们提到过系统在加载storyboard的时候会做以下三件事情

  1. 创建窗口
  2. 加载mian.storyboard 并实例化ViewController
  3. 分配新视图控制器到窗口rootViewcontroller,然后使窗口显在示屏幕上。

那么我们用代码来模拟实现一下

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // 1.创建窗口
    self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];

    // 2.加载main.storyboard,创建main.storyboard描述的控制器
    // UIStoryboard专门用来加载stroyboard
    // name:storyboard名称不需要后缀
    UIStoryboard *stroyboard = [UIStoryboard storyboardWithName:@"Main" bundle:nil];

    // 加载sotryboard描述的控制器
    // 加载箭头指向的控制器
    UIViewController *vc = [stroyboard instantiateInitialViewController];
    //根据绑定标识加载 
    //UIViewController *vc = [stroyboard instantiateViewControllerWithIdentifier:@"red"];

    // 设置窗口的根控制器
    self.window.rootViewController = vc;

    // 3.显示窗口
    [self.window makeKeyAndVisible];

    return YES;
}

2.4 通过xib加载控制器

通过xib加载控制器和通过storyboard加载控制器类似，直接上代码

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];

    // 创建窗口的根控制器
    // 通过xib创建控制器
    ViewController *vc = [[ViewController alloc] initWithNibName:@"VC" bundle:nil];

    //vc.view.backgroundColor = [UIColor redColor];

    self.window.rootViewController = vc;

    [self.window makeKeyAndVisible];

    return YES;
}

3.UIWindow的层级

UIWindow是有层级的，层级高的显示在最外面，当层级相同时，越靠后调用的显示在外面。

UIKIT_EXTERN const UIWindowLevel UIWindowLevelNormal; //默认，值为0
UIKIT_EXTERN const UIWindowLevel UIWindowLevelAlert; //值为2000 
UIKIT_EXTERN const UIWindowLevel UIWindowLevelStatusBar ; // 值为1000

所以UIWindowLevelNormal < UIWindowLevelStatusBar< UIWindowLevelAlert
并且层级是可以做加减的self.window.windowLevel = UIWindowLevelAlert+1;

四、事件响应者链

1. 事件响应者UIResponder

我们在上一篇文章已经介绍过了 事件响应者UIResponder 我们回顾一下它的主要职责:

  • UIResponder是iOS中所有响应者对象的基类，包括视图View、视图控制器ViewController和应用程序对象Application等。
  • UIResponder负责响应并处理来自用户的触摸事件、按压事件、加速事件、远程控制事件、键盘事件和其他事件。

对象派生链

我们在上一篇文章中也介绍了UIKit框架中对象的 继承架构图,从图中我们可以明确得到一个类的派生关系链:

  • UIResponder
    • UIView
      • ...
    • UIViewController
      • ...
    • UIApplication

换言之:

  • UIResponder是iOS中所有响应者对象的基类，包括UIApplication，UIViewController和UIView等都是继承自它。
    • 都有一个 nextResponder 方法，用于获取响应链中当前对象的下一个响应者，也通过nextResponder来串成响应链。
  • 视图View、视图控制器ViewController和应用程序对象Application等都可以作为事件响应者对象

UIResponder 的头文件的几个属性和方法


NS_CLASS_AVAILABLE_IOS(2_0) @interface UIResponder : NSObject <UIResponderStandardEditActions>

#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic, readonly, nullable) UIResponder *nextResponder;
#else
- (nullable UIResponder*)nextResponder;
#endif

--------------省略部分代码------------

  // Generally, all responders which do custom touch handling should override all four of these methods.
// Your responder will receive either touchesEnded:withEvent: or touchesCancelled:withEvent: for each
// touch it is handling (those touches it received in touchesBegan:withEvent:).
// *** You must handle cancelled touches to ensure correct behavior in your application.  Failure to
// do so is very likely to lead to incorrect behavior or crashes.
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesEstimatedPropertiesUpdated:(NSSet<UITouch *> *)touches NS_AVAILABLE_IOS(9_1);

2. 事件响应者链（Responder Chain)

事件响应者链（Responder Chain）是iOS中用于处理事件响应的一种机制，它是由一系列UIResponder对象(UIResponder派生类的实例对象)构成的链式结构，用于确定事件响应的传递路径。

2.1 UIView的两个核心API

在介绍 事件响应者链 前,我们需要先了解两个API:

 // recursively calls -pointInside:withEvent:. point is in the receiver's coordinate system
//返回寻找到的最终响应这个事件的视图
- (nullable UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event;  

// default returns YES if point is in bounds
//判断某一个点击的位置是否在视图范围内
- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event;

2.1.1 hitTest:withEvent: 

/**
 * @return 本次点击事件需要的最佳 View
 */
- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
  • UIKit 使用基于视图的 hit-testing 来确定 Touch 事件在哪里产生
    • UIKit 将 Touch 位置与视图层级中的视图对象的边界进行了比较。
    • UIView 的 hitTest:withEvent: 方法在视图层级中执行，寻找最深的包含指定 Touch 的子视图
    • 这个视图将成为 Touch 事件的第一响应者
  • 注意:
    • 如果 Touch 位置超过视图边界，hitTest:withEvent 方法将忽略这个视图和它的所有子视图。
      • 结果就是，当视图的clipsToBounds 属性为 NO，子视图超过视图边界也不会返回，即使它们包含发生的 Touch。
    • 当 touch 第一次产生时 UIKit 创建 UITouch 对象，在 touch 结束时释放这个 UITouch对象。
    • 当 touch 位置或者其他参数改变时，UIKit 更新 UITouch 对象新的信息

案例说明1

image.png

  • 把父视图的 userInteractionEnabled 设置为 NO，按钮 1 和按钮 2 都不会响应了
  • 如果点击按钮 2 视图，响应的是按钮 2，那么为什么点击按钮 2 和按钮 1 的交界处会是按钮 2 响应呢?
  • 事件传递给窗口或控件的后，就调用 hitTest:withEvent: 方法寻找更合适的 view。如果子控件是合适的 view，则在子控件再调用 hitTest:withEvent: 查看子控件是不是合适的 view，一直遍历，直到找到最合适的 view 或者废弃事件。
- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
   // ①、判断当前控件能否接收事件
   if (self.userInteractionEnabled == NO || self.hidden == YES || self.alpha <= 0.01) return nil;

   // ②、判断触摸点在不在当前控件内
   if ([self pointInside:point withEvent:event] == NO) return nil;

   // ②、倒序遍历自己的子控件
   NSInteger count = self.subviews.count;
   for (NSInteger i = count - 1; i >= 0; i--) {

       UIView * childView = self.subviews[i];
       // 把当前控件上的坐标系转换成子控件上的坐标系
       CGPoint childP = [self convertPoint:point toView:childView];

       UIView * fitView = [childView hitTest:childP withEvent:event];
       if (fitView) { 
           return fitView;  // 找到了最合适的 view
       }
   }
   // 循环结束，表示没有比自己更合适的 view
   return self;  
}
  • 所有当父视图 userInteractionEnabled 关闭时，return nil，子视图无法继续寻找最合适的 view。
  • 从后往前遍历子控件，图中按钮 2 在按钮 1 视图层级之上，所以按钮 2 是最合适的 view，还没有轮到按钮 1。

案例说明2

image.png

  • 视图层级从后往前依次是 C->D->A、E->F->B->父视图，父视图的 subviews = @[ B, A ]。当点击界面发生触摸事件时，遍历父视图的子视图，倒序遍历，先遍历的 A 视图。
  • 如果 A 视图 alpha < 0.01 || userInteractionEnabled = YES || hidden ＝ NO，则 A 视图不是合适的View，返回 nil。开始遍历父视图的另一个子视图 B。
  • 如果 A 视图 alpha > 0.01 && userInteractionEnabled = YES && hidden ＝ NO，则 A 视图可以接收触摸事件，并且触摸点在 A 视图内，则 A 视图为一个合适的 View，但还要继续从后往前遍历 A 视图的子视图；如果 A 视图的所有子视图返回 nil，则 A 视图则为最终合适的 view。
  • 如果 C 视图可以接收触摸事件且触摸点在 C 视图中，并且 C 视图的所有子视图返回 nil。
  • 如果 C 视图调用 hitTest:withEvent: 处理返回 nil，则查看 B 视图满足条件。以此类推。

2.1.2 pointInside:withEvent:

  • 判断触摸点是否在视图内:

    /**
 * @brief  判断一个点是否落在范围内
 */
- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event

  • 如果现在要扩大按钮 2 的点击范围怎么办？如果要让按钮 1 只点击左右区域 40 像素有效，其他地方都不响应呢?image.png

    • 扩大响应范围: 
      - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    /* Inset `rect' by `(dx, dy)' -- i.e., offset its origin by `(dx, dy)', and decrease its size by `(2*dx, 2*dy)'. 

       CGRectInset 效果为 origin.x/y + dx/dy，size.width/height - 2 * dx/dy，这里 dx = -10，dy = -10
     */
    bounds = CGRectInset(self.bounds, -10, -10);

    return CGRectContainsPoint(bounds, point);
}
    • 不规则的点击区域： 
      /**
 * @brief  改变图片的点击范围
 */
- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    // 控件范围宽度 +40，高度 +40
    CGRect bounds = CGRectInset(self.bounds, -20, -20);
    UIBezierPath * path1 = [UIBezierPath bezierPathWithRect:CGRectMake(-20, 0, 40, 120)];
    UIBezierPath * path2 = [UIBezierPath bezierPathWithRect:CGRectMake(self.frame.size.width - 20, 0, 40, 120)];
    if (([path1 containsPoint:point] || [path2 containsPoint:point])&& CGRectContainsPoint(bounds, point)){

        return YES;  // 如果在 path 区域内返回 YES
    }
    return NO;
}

  • 可以看出：

    • 在不规则区域内（红框）点击，[self pointInside:point withEvent:event] == YES，按钮 1 是最合适的 view，调用按钮 1 的点击事件。
    • 不在不规则区域内点击，无法调用按钮 1 的点击事件，[self pointInside:point withEvent:event] == NO。
    • 在按钮 1 和按钮 2 重合区域（绿框）内点击
      • 调用按钮 2 的点击事件，因为按钮 2 图层在按钮 1 之上，遍历 subviews 时，从后往前遍历，先查看按钮 2
      • 按钮 2 调用 -hitTest:withEvent: 返回是最合适的 view，调用按钮 2 的点击方法。

2.1 事件传递链

1. 事件的分发和传递

  • 当 iOS 程序中发生触摸事件后，系统会将事件加入到 UIApplication 管理的一个任务队列中；
  • UIApplication 将处于任务队列最前端的事件向下分发，即 UIWindow。
  • UIWindow 将事件向下分发，即 UIView。
  • UIView
    • 首先看自己是否能处理事件:
    • 触摸点是否在自己身上。如果能，那么继续寻找子视图。
    • 遍历子控件，重复以上两步。
    • 如果没有找到，那么自己就是事件处理者。
    • 如果自己不能处理，那么不做任何处理。
  • 其中 UIView 不接受事件处理的情况主要有以下三种：
    • alpha < 0.01
    • userInteractionEnabled = NO
      • UIImageView的该属性值默认为NO
    • hidden ＝ YES
  • 这个从父控件到子控件寻找处理事件最合适的 view 的过程，如果父视图不接受事件处理，那么子视图也不能接收事件。
  • 事件只要触摸了就会产生，关键在于是否有最合适的 view 来处理和接收事件
  • 如果遍历到最后都没有最合适的 view 来接收事件，则该事件被废弃

2.2 响应者链

  • 响应链是从最合适的 view 开始传递，处理事件传递给下一个响应者，
    • 响应者链的传递方法是事件传递的反方法
    • 如果所有响应者都不处理事件，则事件被丢弃。
    • 我们通常用响应者链来获取上几级响应者，方法是 UIResponder.nextResponder。
  • 在 App 中没有单一的响应链，UIKit 定义了默认的规则关于对象如何从一个响应者传递到另一个响应者，但是你可以重写响应者对象的方法来改变这些规则。
  • 通过重写响应对象的 nextResponder 属性改变响应链。许多 UIKit 的类已经重写了这个属性然后返回了指定的对象。
  • UIView
    • 如果视图是 ViewController 的根视图，下一个响应者为 ViewController
    • 否则是视图的父视图。
  • UIViewController
    • 如果视图控制器是 window 的根视图下一个响应者为 window 对象。
    • 如果视图控制器是由另一个视图控制器推出来，那么下一个响应者为正在推出的视图控制器。
  • UIWindow 下一个响应者为 UIApplication 对象。
  • UIApplication 下一个响应者为 app delegate，但是代理应该是 UIResponder 的一个实例，而不是 UIView、UIViewController 或者 App 对象本身

3. 事件的第一响应者

  • 事件的每个类型, UIKit 指定一个第一响应者, 然后最先发送事件到这个对象。第一响应者基于事件的类型而变化。
    • Touch event 第一响应者是触摸事件产生的 view；
    • Press event 第一响应者是焦点响应者；
    • Shake-motion events,Remote-control events,Editing menu messages 第一响应者是你或者 UIKit 指定的对象。
  • 注意：运动事件相关的加速度计、陀螺仪、磁强计都不属于响应者链，而是由 CoreMotion 传递事件给你指定的对象。
  • 控件直接与它相关的 target 对象使用 action 消息通信。
    • 当用户与控件交互时，控件调用 target 对象的 action 方法。换句话说，控件发送 action 消息到目标对象。
    • Action 消息不是事件，但是它仍然可以利用响应链。
    • 当控件的 target 对象为 nil，UIKit 从 target 对象和响应链走，直到找到一个对象实现了合适的 action 方法。
  • 如果视图有添加手势识别器，手势识别器接收 touch 和 press 事件在视图接收事件之前。
    • 如果所有的视图的手势识别器都不能识别它们的手势，这些事件会传递到视图处理。
    • 如果视图不能处理它们，UIKit 传递事件到响应链。

02-iOS 多媒体技术| 图形处理框架-UIKit要点回顾1【UITouch、UIEvent、手势处理、UIResponder、UIApplication等】

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

前言

我们在前面一篇文章中,对在iOS视觉处理相关框架进行了简介。

在本篇文章主要针对 其中 的 UIKit框架的核心要点,进行一个回顾,作为一个复习和总结。

UIKit框架 是iOS应用程序开发的基础框架之一，也是iOS开发中的一个核心框架。它提供了一系列的类和组件,通过UIKit，开发者可以快速构建各种界面元素、实现用户交互和动画效果。

现在Apple也推出了 SwiftUI 用于 构建界面,实现用户交互 和 动画。我比较倾向于 在写 灵动岛 适配的时候使用 SwiftUI ,做应用的业务页面的时候,使用 UIKit框架

一、UIKit中的核心对象

UIKit框架的职责

我们先引入一段官方对UIKit的介绍

UIKit provides a variety of features for building apps, including components you can use to construct the core infrastructure of your iOS, iPadOS, or tvOS apps. The framework provides the window and view architecture for implementing your UI, the event-handling infrastructure for delivering Multi-Touch and other types of input to your app, and the main run loop for managing interactions between the user, the system, and your app.

Image of an iPhone and iPad running apps that showcase UIKit user interface elements. The iPhone is running a sample app that shows a color picker and a navigation bar. The iPad is running a sample app that shows a split-view interface with an outline view, a list of recipes, and a detail view with information about a specific recipe.

UIKit also includes support for animations, documents, drawing and printing, text management and display, search, app extensions, resource management, and getting information about the current device. You can also customize accessibility support, and localize your app’s interface for different languages, countries, or cultural regions.

UIKit works seamlessly with the SwiftUI framework, so you can implement parts of your UIKit app in SwiftUI or mix interface elements between the two frameworks. For example, you can place UIKit views and view controllers inside SwiftUI views, and vice versa.

To build a macOS app, you can use SwiftUI to create an app that works across all of Apple’s platforms, or use AppKit to create an app for Mac only. Alternatively, you can bring your UIKit iPad app to the Mac with Mac Catalyst.

Important

Use UIKit classes only from your app’s main thread or main dispatch queue, unless otherwise indicated in the documentation for those classes. This restriction particularly applies to classes that derive from UIResponder or that involve manipulating your app’s user interface in any way.

简扼地概括一下UIKit框架的职责就是:

  • 通过UIKit，开发者可以快速构建各种界面元素、实现用户交互和动画效果等。
    • 构建UI界面
      • 用于实现 UI 的窗口和视图架构
    • 交互事件处理
      • 用于向应用程序提供多点触控和其他类型输入的事件处理基础设施
      • 用于管理用户、系统和应用程序之间交互的主运行循环
    • 动画效果等
      • UIKit 还包括对动画、文档、绘图和打印、文本管理和显示、搜索、应用程序扩展、资源管理以及获取有关当前设备的信息的支持。您
  • 只可以通过主线程或者主队列中进行对UIKit中的类的使用(凡是由UIResponder派生的类在没有任何相关说明时都适用)
  • UIKit 可以 与 SwiftUI无缝协作

继承架构图

首先 引入 一张 继承架构图: 我们从这张继承架构图,可以看到,UIKit中的所有类都继承自OC中的基类NSObject(Swift中虽然重写了UIKit的核心类、Foundation的核心类,这一点同样适用)

image.pngimage.png

想进一步了解Cocoa框架中,UIKit框架类继承体系可以参考我的 这篇文章

1. 核心对象和核心要点

UIKit中的 核心要点 和 核心类 我们前面已经 了解了 UIKit框架的 职责 和 UIKit框架 类的继承关系。 现在 我们不难 得出 UIKit框架的核心要点:

image.png

  • 交互事件处理的基础架构。相关类:
    • UIEvent
    • UITouch
    • 用户与应用程序的交互
      • UIGestureRecognizer
    • UIResponder
    • 系统与应用程序的交互
      • AppDelegate(遵守了UIApplicationDelegate协议)
    • 其他事件输入:
      • ...
  • 构建UI界面的基础架构。相关类:
    • UIScreen
    • (派生自UIResponder)
      • UIView
        • UIWindow
        • UIControl
          • UIButton
      • UIApplication
      • UIViewController

2. UIKit中常用的UI组件

根据我们多年的项目实施经验,我们可以把UIKit框架中常用的UI组件列举出来,为了更直观地了解类重要程度,我们 按照派生关系的方式列举:

  • UIResponder
    • UIView
      • UIWindow
      • UILabel
      • UIImageView
      • UIScrollView
        • UITableView
        • UICollectionView
        • UITextView
      • UITableViewCell
      • UIStackView
      • UIControl
        • UIButton
        • UITextField
        • UISwitch
        • UISlider
        • UIDatePicker
        • UIPageControl
        • UISegmentControl
      • UIWebView(已经有更优秀的WKWebView代替)
      • WKWebView
      • UITabBar
      • UINavigationBar
      • UIToolBar
      • UIAlertView
      • UIActionSheet
      • UIProgressView
      • UIPickerView
      • UISearchBar
      • UIActivityIndicatorView
    • UIViewController
      • UITabBarController
      • UINavigationController
        • UIImagePickerController
        • UIVideoEditorController
      • UISplitViewController(iPad开发)
      • UISearchController

二、事件交互|UITouch

1. UITouch简介

UITouch 类是用于记录触控事件的对象

  • 每当用户在屏幕上触摸时，系统就会生成一个 UITouch 对象来表示这次触摸事件的相关信息
  • 记录的事件信息包括屏幕上发生的触摸的:位置、size尺寸、时间、阶段、移动和力度。

2. UITouch的创建与销毁

  • 当用户用一根手指触摸屏幕时，会创建一个与手指相关联的UITouch对象，一根手指对应一个UITouch对象。
  • 当手指移动时，系统会更新同一个UITouch对象，使之能够一直保存该手指在的触摸位置。
  • 当手指离开屏幕时，系统会销毁相应的UITouch对象

3. UITouch记录触控事件的常用属性

触摸产生时所处的窗口
@property(nonatomic,readonly,retain) UIWindow    *window;
触摸产生时所处的视图
@property(nonatomic,readonly,retain) UIView      *view;
短时间内点按屏幕的次数，可以根据tapCount判断单击、双击或更多的点击
@property(nonatomic,readonly) NSUInteger          tapCount;
记录了触摸事件产生或变化时的时间，单位是秒
@property(nonatomic,readonly) NSTimeInterval      timestamp;
当前触摸事件所处的状态,包括`began`、`moved`、`stationary`、`ended` 和 `cancelled`
@property(nonatomic,readonly) UITouchPhase        phase;

typedef NS_ENUM(NSInteger, UITouchPhase) {
    UITouchPhaseBegan,             // 表示触摸事件刚开始，手指刚接触到屏幕的时刻。whenever a finger touches the surface. 
    UITouchPhaseMoved,             // 表示手指在屏幕上移动时的阶段，即触摸事件的位置发生了变化 whenever a finger moves on the surface.
    UITouchPhaseStationary,        // 表示触摸事件的位置在屏幕上保持不变，手指未发生移动 whenever a finger is touching the surface but hasn't moved since the previous event.
    UITouchPhaseEnded,             // 表示触摸事件结束，手指从屏幕上抬起的时刻whenever a finger leaves the surface.
    UITouchPhaseCancelled,         // 表示触摸事件被取消，通常是因为系统中断了触摸事件的处理，例如突然来电、系统警告等情况 whenever a touch doesn't end but we need to stop tracking (e.g. putting device to face)
    UITouchPhaseRegionEntered   API_AVAILABLE(ios(13.4), tvos(13.4)) API_UNAVAILABLE(watchos),  // whenever a touch is entering the region of a user interface
    UITouchPhaseRegionMoved     API_AVAILABLE(ios(13.4), tvos(13.4)) API_UNAVAILABLE(watchos),  // when a touch is inside the region of a user interface, but hasn’t yet made contact or left the region
    UITouchPhaseRegionExited    API_AVAILABLE(ios(13.4), tvos(13.4)) API_UNAVAILABLE(watchos),  // when a touch is exiting the region of a user interface
};

4. UITouch|获取触控位置的常用方法

- (CGPoint)locationInView:(UIView *)view;
//返回值表示触摸在view上的位置
//这里返回的位置是针对view的坐标系的（以view的左上角为原点(0, 0)）
//调用时传入的view参数为nil的话，返回的是触摸点在UIWindow的位置
- (CGPoint)previousLocationInView:(UIView *)view;
//记录了前一个触摸点的位置

三、事件交互|UIEvent

1. UIEvent简介

UIEvent: 是事件对象，用于记录事件产生的时刻和事件类型 每产生一个事件，就会产生一个UIEvent对象

2. UIEvent事件类型介绍

应用程序可以接收许多不同类型的事件，包括触摸事件、运动事件、远程控制事件和按压事件。

  • 触摸事件是最常见的，并且被传递到最初发生触摸的视图。
  • 运动事件由 UIKit 触发，并且与 Core Motion 框架报告的运动事件分开。
  • 远程控制事件允许响应者对象接收来自外部配件或耳机的命令，以便它可以管理音频和视频。例如:
    • 播放视频或跳到下一个音轨
    • 按下事件表示与游戏控制器、Apple TV 遥控器或其他具有物理按钮的设备的交互。type您可以使用和属性确定事件的类型subtype。
  1. 触摸事件（Touch Events） ：
    • UIEventSubtype.touches: 表示触摸事件的子类型。它包括以下几种：
      • UIEventSubtype.touchesBegan: 表示触摸事件开始。
      • UIEventSubtype.touchesMoved: 表示触摸事件移动。
      • UIEventSubtype.touchesEnded: 表示触摸事件结束。
      • UIEventSubtype.touchesCancelled: 表示触摸事件被取消。
  2. 摇晃事件（Motion Events） ：
    • UIEventSubtype.motionShake: 表示设备摇晃事件。
  3. 远程控制事件（Remote Control Events） ：
    • UIEventSubtype.remoteControlPlay: 表示远程控制播放事件。
    • UIEventSubtype.remoteControlPause: 表示远程控制暂停事件。
    • UIEventSubtype.remoteControlStop: 表示远程控制停止事件。
    • UIEventSubtype.remoteControlTogglePlayPause: 表示远程控制切换播放/暂停事件。
    • UIEventSubtype.remoteControlNextTrack: 表示远程控制下一曲事件。
    • UIEventSubtype.remoteControlPreviousTrack: 表示远程控制上一曲事件。
    • UIEventSubtype.remoteControlBeginSeekingBackward: 表示远程控制开始后退事件。
    • UIEventSubtype.remoteControlEndSeekingBackward: 表示远程控制结束后退事件。
    • UIEventSubtype.remoteControlBeginSeekingForward: 表示远程控制开始快进事件。
    • UIEventSubtype.remoteControlEndSeekingForward: 表示远程控制结束快进事件。
  4. 按键事件（Press Events） ：
    • UIEventSubtype.presses: 表示按键事件的子类型。它包括以下几种：
      • UIEventSubtype.pressesBegan: 表示按键事件开始。
      • UIEventSubtype.pressesChanged: 表示按键事件发生变化。
      • UIEventSubtype.pressesEnded: 表示按键事件结束。
      • UIEventSubtype.pressesCancelled: 表示按键事件被取消。

3. UIEvent记录事件信息的常用属性

//事件类型
@property(nonatomic,readonly) UIEventType     type;
@property(nonatomic,readonly) UIEventSubtype  subtype;
//事件产生的时间
@property(nonatomic,readonly) NSTimeInterval  timestamp;

4. UIEvent|不同事件类型的回调方法

各类型事件的回调方法都在UIResponder中

4.1 触控事件

// Generally, all responders which do custom touch handling should override all four of these methods.
// Your responder will receive either touchesEnded:withEvent: or touchesCancelled:withEvent: for each
// touch it is handling (those touches it received in touchesBegan:withEvent:).
// *** You must handle cancelled touches to ensure correct behavior in your application.  Failure to
// do so is very likely to lead to incorrect behavior or crashes.

//触摸开始
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
//触摸移动
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
//触摸结束
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
//触摸取消
- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesEstimatedPropertiesUpdated:(NSSet<UITouch *> *)touches API_AVAILABLE(ios(9.1));

单点触控和多点触控

  • 4个触摸事件处理方法中，都有 NSSet<*touches> 和 UIEvent *event 两个参数
  • 一次完整的触摸过程中，只会产生一个事件对象，4个触摸方法都是同一个event参数
  • 如果两根手指同时触摸一个view，那么view只会调用一次touchesBegan:withEvent:方法，touches参数中装着2个UITouch对象
  • 如果这两根手指一前一后分开触摸同一个view，那么view会分别调用2次touchesBegan:withEvent:方法，并且每次调用时的touches参数中只包含一个UITouch对象
  • 所以根据touches中UITouch的个数可以判断出是单点触摸还是多点触摸

4.2 按键事件

// Generally, all responders which do custom press handling should override all four of these methods.
// Your responder will receive either pressesEnded:withEvent or pressesCancelled:withEvent: for each
// press it is handling (those presses it received in pressesBegan:withEvent:).
// pressesChanged:withEvent: will be invoked for presses that provide an analog value
// (like thumbsticks or analog push buttons)
// *** You must handle cancelled presses to ensure correct behavior in your application.  Failure to
// do so is very likely to lead to incorrect behavior or crashes.

- (void)pressesBegan:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event API_AVAILABLE(ios(9.0));
- (void)pressesChanged:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event API_AVAILABLE(ios(9.0));
- (void)pressesEnded:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event API_AVAILABLE(ios(9.0));
- (void)pressesCancelled:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event API_AVAILABLE(ios(9.0));

4.3 摇晃事件

- (void)motionBegan:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event API_AVAILABLE(ios(3.0));
- (void)motionEnded:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event API_AVAILABLE(ios(3.0));
- (void)motionCancelled:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event API_AVAILABLE(ios(3.0));

4.4 远程控制事件

- (void)remoteControlReceivedWithEvent:(nullable UIEvent *)event API_AVAILABLE(ios(4.0));

四、事件交互|UIGestureRecognizer

1. UIGestureRecognier简介

  • iOS 3.2之后，苹果推出了手势识别功能（Gesture Recognizer），在触摸事件处理方面，大大简化了开发者的开发难度。
  • 利用UIGestureRecognizer，能轻松识别用户在某个view上面做的一些常见手势。
  • UIGestureRecognizer是一个抽象类，对iOS中的事件传递机制面向应用进行封装，将手势消息的传递抽象为了对象。
  • 其中定义了所有手势的基本行为，使用它的子类才能处理具体的手势。

2. 手势的抽象类——UIGestureRecognizer

UIGestureRecognizer将一些和手势操作相关的方法抽象了出来，但它本身并不实现什么手势，因此，在开发中，我们一般不会直接使用UIGestureRecognizer的对象，而是通过其子类进行实例化，iOS系统给我们提供了许多用于实例的子类，这些我们后面再说，我们先来看一下，UIGestureRecognizer中抽象出了哪些方法。

2.1 初始化方法

UIGestureRecognizer类为其子类准备好了一个统一的初始化方法，无论什么样的手势动作，其执行的结果都是一样的：

  • 初始化
    触发一个方法，可以使用下面的方法进行统一的初始化：

    - (instancetype)initWithTarget:(nullable id)target action:(nullable SEL)action

  • 当然，如果我们使用alloc-init的方式，也是可以的，下面的方法可以为手势添加触发的selector：

    - (void)addTarget:(id)target action:(SEL)action;

  • 手势移除
    与之相对应的，我们也可以将一个selector从其手势对象上移除：

    - (void)removeTarget:(nullable id)target action:(nullable SEL)action;

  • 一个手势,多个触发方法
    因为addTarget方式的存在，iOS系统允许一个手势对象可以添加多个selector触发方法，并且触发的时候，所有添加的selector都会被执行，我们以点击手势示例如下：

    - (void)viewDidLoad {
    [super viewDidLoad];
    UITapGestureRecognizer *tap1 = [[UITapGestureRecognizer alloc]initWithTarget:self action:@selector(tap1:)];
    [tap1 addTarget:self action:@selector(tap2:)];
    [self.view addGestureRecognizer:tap1];
}
-(void)tap1:(UITapGestureRecognizer *)tap
{
    NSLog(@"%s",__func__);
}
-(void)tap2:(UITapGestureRecognizer *)tap
{
    NSLog(@"%s",__func__);
}

点击屏幕，打印内容如下，说明两个方法都触发了

2.2 手势状态

UIGestureRecognizer类中有如下一个属性，里面枚举了一些手势的当前状态:

@property(nonatomic,readonly) UIGestureRecognizerState state;

枚举值如下：

typedef NS_ENUM(NSInteger, UIGestureRecognizerState) {
    UIGestureRecognizerStatePossible,   // 默认的状态，这个时候的手势并没有具体的情形状态
    UIGestureRecognizerStateBegan,      // 手势开始被识别的状态
    UIGestureRecognizerStateChanged,    // 手势识别发生改变的状态
    UIGestureRecognizerStateEnded,      // 手势识别结束，将会执行触发的方法
    UIGestureRecognizerStateCancelled,  // 手势识别取消
    UIGestureRecognizerStateFailed,     // 识别失败，方法将不会被调用
    UIGestureRecognizerStateRecognized = UIGestureRecognizerStateEnded 
};

2.3 常用属性和方法

//手势代理 代理中有一些手势触发的方法，后面拿出来详细说明
@property(nullable,nonatomic,weak) id <UIGestureRecognizerDelegate> delegate; 
//设置手势是否有效
@property(nonatomic, getter=isEnabled) BOOL enabled;  
//获取手势所在的View
@property(nullable, nonatomic,readonly) UIView *view;          
//默认是YES。当识别到手势的时候，终止touchesCancelled:withEvent:或pressesCancelled:withEvent:发送的所有触摸事件。
@property(nonatomic) BOOL cancelsTouchesInView;     
//默认为NO ,在触摸开始的时候，就会发消息给事件传递链，如果设置为YES，在触摸没有被识别失败前，都不会给事件传递链发送消息。  
@property(nonatomic) BOOL delaysTouchesBegan;    
//默认为YES 。这个属性设置手势识别结束后，是立刻发送touchesEnded或pressesEnded消息到事件传递链或者等待一个很短的时间后，如果没有接收到新的手势识别任务，再发送。
@property(nonatomic) BOOL delaysTouchesEnded;         

@property(nonatomic, copy) NSArray<NSNumber *> *allowedTouchTypes NS_AVAILABLE_IOS(9_0); // Array of UITouchType's as NSNumbers.
@property(nonatomic, copy) NSArray<NSNumber *> *allowedPressTypes NS_AVAILABLE_IOS(9_0); // Array of UIPressTypes as NSNumbers.

//[A requireGestureRecognizerToFail：B]手势互斥 它可以指定当A手势发生时，即便A已经滿足条件了，也不会立刻触发，会等到指定的手势B确定失败之后才触发。
- (void)requireGestureRecognizerToFail:(UIGestureRecognizer *)otherGestureRecognizer;
//获取当前触摸的点
- (CGPoint)locationInView:(nullable UIView*)view;
//设置触摸点数
- (NSUInteger)numberOfTouches;
//获取某一个触摸点的触摸位置
- (CGPoint)locationOfTouch:(NSUInteger)touchIndex inView:(nullable UIView*)view;

2.3.1 个别属性详解

其中几个BOOL值的属性，对于手势触发的控制也十分重要:

@property(nonatomic) BOOL cancelsTouchesInView;
@property(nonatomic) BOOL delaysTouchesBegan;
@property(nonatomic) BOOL delaysTouchesEnded;

- (void)viewDidLoad {
    [super viewDidLoad];
    UIPanGestureRecognizer *pan = [[UIPanGestureRecognizer alloc]initWithTarget:self action:@selector(pan:)];
    pan.cancelsTouchesInView = NO;
//    pan.delaysTouchesBegan = YES;
    [self.view addGestureRecognizer:pan];    
}
-(void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    NSLog(@"touchMoved手势触发");
}
-(void)pan:(UIPanGestureRecognizer *)pan{
    NSLog(@"pan手势触发");
}

pan.cancelsTouchesInView属性默认设置为YES

  • 如果识别到了手势，系统将会发送touchesCancelled:withEvent:消息在其时间传递链上，终止触摸事件的传递
  • 也就是说默认当识别到手势时，touch事件传递的方法将被终止而不执行，如果设置为NO，touch事件传递的方法仍然会被执行
  • 上例中我们使用了Pan手势和touchesMoved两个触发方式
  • 当我们把cancelTouchesInView设置为NO时，在屏幕上滑动，两种方式都在触发，打印如下： pan.cancelsTouchesInView = NO
  • 而当我们将pan.cancelsTouchesInView = YES属性设置为YES时，打印结果如下
    pan.cancelsTouchesInView = YES
    • 我们发现touchesMoved的方法仍然被调用了，这是为什么呢？
    • 这就涉及到第二个属性delaysTouchesBegan
      • 这是因为手势识别是有一个过程的，拖拽手势需要一个很小的手指移动的过程才能被识别为拖拽手势
      • 而在一个手势触发之前，是会一并发消息给事件传递链的，所以才会有最开始的几个touchMoved方法被调用，当识别出拖拽手势以后，就会终止touch事件的传递。
      • delaysTouchesBgan属性用于控制这个消息的传递时机，默认这个属性为NO，此时在触摸开始的时候，就会发消息给事件传递链
      • 如果我们设置为YES，在触摸没有被识别失败前，都不会给事件传递链发送消息。
        因此当我们设置pan.delaysTouchesBegan = YES;时打印内容如下
        pan.delaysTouchesBegan = YES
      • 因为此时在拖拽手势识别失败之前，都不会给时间传递链发送消息，所以就不会在调用touchesMoved触发事件了
      • 而delaysTouchesEnded属性默认是YES，当设为YES时在手势识别结束后，会等待一个很短的时间，如果没有接收到新的手势识别任务，才会发送touchesEnded消息到事件传递链，设置为NO之后会立刻发送touchesEnded消息到事件传递链我们同样来看一个例子：
    - (void)viewDidLoad {
    [super viewDidLoad];
    UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc]initWithTarget:self action:@selector(tap:)];
    tap.numberOfTapsRequired = 3;
// tap.cancelsTouchesInView = NO;
// tap.delaysTouchesBegan = YES;
    tap.delaysTouchesEnded = NO;
    [self.view addGestureRecognizer:tap];    
}
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    NSLog(@"touchBegan手势开始");
}
-(void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    NSLog(@"touchEnd手势触发结束");
}
-(void)tap:(UITapGestureRecognizer *)tap
{
    NSLog(@"tap手势触发");
}
  • 当tap.delaysTouchesEnded = NO;时，轻拍三下屏幕，打印如下 tap.delaysTouchesEnded = NO
  • 我们发现我们每点击一下，都会立即发送touchesEnded消息到事件传递链。
    而当tap.delaysTouchesEnded = YES;时，轻拍三下屏幕，打印如下
    tap.delaysTouchesEnded = YES
  • 等三下轻拍手势识别结束后，才会发送消息到事件传递链。

2.3.2 重点方法详解-手势间的互斥处理

  • 同一个View上是可以添加多个手势对象的，默认这些手势是互斥的。一个手势触发了就会默认屏蔽其他相似的手势动作
  • 比如:
    • 单击和双击并存时，如果不做处理，它就只能发送出单击的消息。
    • 为了能够识别出双击手势，就需要用下面的方法一个特殊处理逻辑，即先判断手势是否是双击，在双击失效的情况下作为单击手势处理。
- (void)requireGestureRecognizerToFail:(UIGestureRecognizer *)otherGestureRecognizer;

**[A requireGestureRecognizerToFail：B] **

  • 它可以指定当A手势发生时，即便 A已经满足条件了，也不会立刻触发，
  • 会等到指定的手势B确定失败之后A才触发。 例子:
- (void)viewDidLoad {
    [super viewDidLoad];
    UITapGestureRecognizer *tap1 = [[UITapGestureRecognizer alloc]initWithTarget:self action:@selector(tap1:)];
    tap1.numberOfTapsRequired = 1;
    [self.view addGestureRecognizer:tap1];
    UITapGestureRecognizer *tap2 = [[UITapGestureRecognizer alloc]initWithTarget:self action:@selector(tap2:)];
    tap2.numberOfTapsRequired = 2;
    [self.view addGestureRecognizer:tap2];  
   //当tap2手势触发失败时才会触发tap1手势
    [tap1 requireGestureRecognizerToFail:tap2];
}
-(void)tap1:(UITapGestureRecognizer *)tap
{
    NSLog(@"tap1手势触发");
}
-(void)tap2:(UITapGestureRecognizer *)tap
{
    NSLog(@"tap2手势触发");
}

2.3.3 UIGestureRecognizerDelegate

前面我们提到过关于手势对象的协议代理，通过代理的回调，我们可以进行自定义手势，也可以处理一些复杂的手势关系，其中方法如下：

//手指触摸屏幕后回调的方法，返回NO则不再进行手势识别，方法触发等
- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldReceiveTouch:(UITouch *)touch;
//开始进行手势识别时调用的方法，返回NO则结束，不再触发手势
- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer;
//是否支持多时候触发，返回YES，则可以多个手势一起触发方法，返回NO则为互斥
- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer;
//下面这个两个方法也是用来控制手势的互斥执行的
//这个方法返回YES，第一个手势和第二个互斥时，第一个会失效
- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRequireFailureOfGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer NS_AVAILABLE_IOS(7_0);
//这个方法返回YES，第一个和第二个互斥时，第二个会失效
- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer NS_AVAILABLE_IOS(7_0);

3. UIGestureRecognizer子类及子类属性

除了UIGestureRecognizer中的方法和属性是所有子类通用的之外，UIGestureRecognizer子类中分别有不同的属性和方法来对应不同的手势。

UIGestureRecognizer的子类:

3.1 UITapGestureRecognizer|点击手势

点击手势十分简单，支持单击和多次点击，在我们手指触摸屏幕并抬起手指时会进行触发，其中有如下两个属性我们可以进行设置：

//设置点击次数，默认为单击
@property (nonatomic) NSUInteger  numberOfTapsRequired; 
//设置同时点击的手指数
@property (nonatomic) NSUInteger  numberOfTouchesRequired;

3.2 UIPinchGestureRecognizer|捏合手势

捏合手势是当我们双指捏合和扩张会触发动作的手势，我们可以设置的属性如下：

//设置缩放比例
@property (nonatomic)          CGFloat scale; 
//设置捏合速度
@property (nonatomic,readonly) CGFloat velocity;

3.3 UIPanGestureRecognzer|拖拽手势

当我们点中视图进行慢速拖拽时会触发拖拽手势的方法。

//设置触发拖拽的最少触摸点，默认为1
@property (nonatomic)          NSUInteger minimumNumberOfTouches; 
//设置触发拖拽的最多触摸点
@property (nonatomic)          NSUInteger maximumNumberOfTouches;  
//获取当前位置
- (CGPoint)translationInView:(nullable UIView *)view;            
//设置当前位置
- (void)setTranslation:(CGPoint)translation inView:(nullable UIView *)view;
//设置拖拽速度
- (CGPoint)velocityInView:(nullable UIView *)view;

3.4 UISwipeGestureRecognizer|滑动手势

滑动手势和拖拽手势的不同之处在于滑动手势更快，而拖拽比较慢。

//设置触发滑动手势的触摸点数
@property(nonatomic) NSUInteger                        numberOfTouchesRequired; 
//设置滑动方向
@property(nonatomic) UISwipeGestureRecognizerDirection direction;  
//枚举如下
typedef NS_OPTIONS(NSUInteger, UISwipeGestureRecognizerDirection) {
    UISwipeGestureRecognizerDirectionRight = 1 << 0,
    UISwipeGestureRecognizerDirectionLeft  = 1 << 1,
    UISwipeGestureRecognizerDirectionUp    = 1 << 2,
    UISwipeGestureRecognizerDirectionDown  = 1 << 3
};

3.5 UIRotationGestureRecognizer|旋转手势

进行旋转动作时触发手势方法。

//设置旋转角度
@property (nonatomic)          CGFloat rotation;
//设置旋转速度 
@property (nonatomic,readonly) CGFloat velocity;

3.6 UILongPressGestureRecognizer|长按手势

进行长按的时候触发的手势方法。

//设置触发前的点击次数
@property (nonatomic) NSUInteger numberOfTapsRequired;    
//设置触发的触摸点数
@property (nonatomic) NSUInteger numberOfTouchesRequired; 
//设置最短的长按时间
@property (nonatomic) CFTimeInterval minimumPressDuration; 
//设置在按触时时允许移动的最大距离 默认为10像素
@property (nonatomic) CGFloat allowableMovement;

3.7 自定义手势

  • 在.m文件中需要引入#import <UIKit/UIGestureRecognizerSubclass.h>。
  • 自定义手势继承：UIGestureRecognizer，
  • 实现下面的方法，在以下方法中判断自定义手势是否实现:
– touchesBegan:withEvent:  
– touchesMoved:withEvent:  
– touchesEnded:withEvent:  
- touchesCancelled:withEvent:

五、事件交互|UIResponder

1. UIResponder简介

  • UIResponder是iOS中所有响应者对象的基类，包括视图View、视图控制器ViewController和应用程序对象Application等。
  • UIResponder负责响应并处理来自用户的触摸事件、按压事件、加速事件、远程控制事件、键盘事件和其他事件。

2. UIResponderStandardEditActions协议介绍

UIResponder遵守了UIResponderStandardEditActions协议,且内部对方法进行了实现

#pragma mark - UIResponderStandardEditActions协议定义
 
@protocol UIResponderStandardEditActions <NSObject>
@optional
/** 剪切事件 */
- (void)cut:(nullable id)sender NS_AVAILABLE_IOS(3_0);
/** 复制事件 */
- (void)copy:(nullable id)sender NS_AVAILABLE_IOS(3_0);
/** 粘贴事件 */
- (void)paste:(nullable id)sender NS_AVAILABLE_IOS(3_0);
/** 选择事件 */
- (void)select:(nullable id)sender NS_AVAILABLE_IOS(3_0);
/** 全选事件 */
- (void)selectAll:(nullable id)sender NS_AVAILABLE_IOS(3_0);
/** 删除事件 */
- (void)delete:(nullable id)sender NS_AVAILABLE_IOS(3_2);
/** 从左到右写入字符串(居左) */
- (void)makeTextWritingDirectionLeftToRight:(nullable id)sender NS_AVAILABLE_IOS(5_0);
/** 从右到左写入字符串(居右) */
- (void)makeTextWritingDirectionRightToLeft:(nullable id)sender NS_AVAILABLE_IOS(5_0);
/** 切换字体为黑体(粗体) */
- (void)toggleBoldface:(nullable id)sender NS_AVAILABLE_IOS(6_0);
/** 切换字体为斜体 */
- (void)toggleItalics:(nullable id)sender NS_AVAILABLE_IOS(6_0);
/** 给文字添加下划线 */
- (void)toggleUnderline:(nullable id)sender NS_AVAILABLE_IOS(6_0);
 
/** 增加字体大小 */
- (void)increaseSize:(nullable id)sender NS_AVAILABLE_IOS(7_0);
/** 减小字体大小 */
- (void)decreaseSize:(nullable id)sender NS_AVAILABLE_IOS(7_0);
 
@end

3. UIResponder 常用属性介绍

#pragma mark - 响应者相关方法
 
/** 获取下一个响应者 */
@property(nonatomic, readonly, nullable) UIResponder *nextResponder;

 
/** 是否允许成为第一响应者。默认返回NO */
@property(nonatomic, readonly) BOOL canBecomeFirstResponder;
/** 设置成为第一响应者 */
- (BOOL)becomeFirstResponder;
 
/** 是否允许放弃第一响应者。默认返回YES */
@property(nonatomic, readonly) BOOL canResignFirstResponder;
/** 设置放弃第一响应者 */
- (BOOL)resignFirstResponder;
 
/** 判断对象是否是第一响应者 */
@property(nonatomic, readonly) BOOL isFirstResponder;

4. UIResponder|触摸事件相关回调方法

#pragma mark - 触摸相关方法，一般用于响应屏幕触摸
/** 手指按下时响应 */
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
/** 手指移动时响应 */
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
/** 手指抬起时响应 */
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
/** 取消(意外中断, 如:电话, 系统警告窗等) */
- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
/** 3DTouch响应(iOS9.1后使用) */
- (void)touchesEstimatedPropertiesUpdated:(NSSet<UITouch *> *)touches NS_AVAILABLE_IOS(9_1);

5. UIResponder|按压事件相关回调方法

#pragma mark - 深按相关方法，一般用于遥控器按键响应
/** 手指按压开始时响应 */
- (void)pressesBegan:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event NS_AVAILABLE_IOS(9_0);
/** 手指按压位置移动时响应 */
- (void)pressesChanged:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event NS_AVAILABLE_IOS(9_0);
/** 手指抬起接受按压时响应 */
- (void)pressesEnded:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event NS_AVAILABLE_IOS(9_0);
/** 按压取消(意外中断, 如:电话, 系统警告窗等) */
- (void)pressesCancelled:(NSSet<UIPress *> *)presses withEvent:(nullable UIPressesEvent *)event NS_AVAILABLE_IOS(9_0);

6. UIResponder|加速事件相关回调方法

#pragma mark - 加速相关方法，一般用于摇一摇、运动事件监听等
/** 开始加速 */
- (void)motionBegan:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(3_0);
/** 结束加速 */
- (void)motionEnded:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(3_0);
/** 加速取消（意外中断, 如:电话, 系统警告窗等） */
- (void)motionCancelled:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(3_0);

7. UIResponder|远程控制事件相关回调方法

/** 远程控制事件 */
- (void)remoteControlReceivedWithEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(4_0);

8. UIResponder|其它方法

//
//  UIResponder.h
//  UIKit
//
//  Copyright (c) 2005-2018 Apple Inc. All rights reserved.
//
//  详解 UIResponder.h
//  Version iOS 10.3
//
 

#import <Foundation/Foundation.h>
#import <UIKit/UIKitDefines.h>
#import <UIKit/UIEvent.h>
#import <UIKit/UIKeyCommand.h>
#import <UIKit/UIPasteConfigurationSupporting.h>
#import <UIKit/UIUserActivity.h>
NS_HEADER_AUDIT_BEGIN(nullability, sendability) 

@class UIPress;
@class UIPressesEvent;
 

#pragma mark - UIResponder类定义
 
NS_CLASS_AVAILABLE_IOS(2_0) NS_SWIFT_UI_ACTOR
@interface UIResponder : NSObject <UIResponderStandardEditActions>
 ...
/** 返回UIMenuController需要显示的控件(如：复制，粘贴等) */
- (BOOL)canPerformAction:(SEL)action withSender:(nullable id)sender NS_AVAILABLE_IOS(3_0);
 
/** 返回响应的操作目标对象 */
- (nullable id)targetForAction:(SEL)action withSender:(nullable id)sender NS_AVAILABLE_IOS(7_0);

/** 获取响应链就近共享撤消管理 */
@property(nullable, nonatomic,readonly) NSUndoManager *undoManager NS_AVAILABLE_IOS(3_0);
 
@end
 
/** 快捷主键枚举 */
typedef NS_OPTIONS(NSInteger, UIKeyModifierFlags) {
    UIKeyModifierAlphaShift     = 1 << 16,  //!< Alpha+Shift键.
    UIKeyModifierShift          = 1 << 17,  //!< Shift键.
    UIKeyModifierControl        = 1 << 18,  //!< Control键.
    UIKeyModifierAlternate      = 1 << 19,  //!< Alt键.
    UIKeyModifierCommand        = 1 << 20,  //!< Command键.
    UIKeyModifierNumericPad     = 1 << 21,  //!< Num键.
} NS_ENUM_AVAILABLE_IOS(7_0);
 
#pragma mark - 快捷键对象
 
NS_CLASS_AVAILABLE_IOS(7_0) @interface UIKeyCommand : NSObject <NSCopying, NSSecureCoding>
 
/** 初始化对象 */
- (instancetype)init NS_DESIGNATED_INITIALIZER;
/** 初始化对象 */
- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder NS_DESIGNATED_INITIALIZER;
 
/** 获取快捷辅键（如快捷命令【Command+A】中的 A 键） */
@property (nonatomic,readonly) NSString *input;
/** 获取快捷主键（如快捷命令【Command+A】中的 Command 键） */
@property (nonatomic,readonly) UIKeyModifierFlags modifierFlags;
/** 显示给用户的快捷键标题 */
@property (nullable,nonatomic,copy) NSString *discoverabilityTitle NS_AVAILABLE_IOS(9_0);
 
/** 创建一个快捷键命令 */
+ (UIKeyCommand *)keyCommandWithInput:(NSString *)input modifierFlags:(UIKeyModifierFlags)modifierFlags action:(SEL)action;
 
/** 创建一个快捷键命令 */
+ (UIKeyCommand *)keyCommandWithInput:(NSString *)input modifierFlags:(UIKeyModifierFlags)modifierFlags action:(SEL)action discoverabilityTitle:(NSString *)discoverabilityTitle NS_AVAILABLE_IOS(9_0);
 
@end
 
#pragma mark - 响应快捷命令
 
@interface UIResponder (UIResponderKeyCommands)
/** 返回快捷键命令数组 */
@property (nullable,nonatomic,readonly) NSArray<UIKeyCommand *> *keyCommands NS_AVAILABLE_IOS(7_0);
@end
 
@class UIInputViewController;
@class UITextInputMode;
@class UITextInputAssistantItem;
 
#pragma mark - 输入视图
 
@interface UIResponder (UIResponderInputViewAdditions)
 
/** 键盘输入视图(系统默认的,可以自定义) */
@property (nullable, nonatomic, readonly, strong) __kindof UIView *inputView NS_AVAILABLE_IOS(3_2);
/** 弹出键盘时附带的视图 */
@property (nullable, nonatomic, readonly, strong) __kindof UIView *inputAccessoryView NS_AVAILABLE_IOS(3_2);
 
/** 输入助手配置键盘的快捷方式栏时使用 */
@property (nonnull, nonatomic, readonly, strong) UITextInputAssistantItem *inputAssistantItem NS_AVAILABLE_IOS(9_0) __TVOS_PROHIBITED __WATCHOS_PROHIBITED;
 
/** 键盘输入视图控制器 */
@property (nullable, nonatomic, readonly, strong) UIInputViewController *inputViewController NS_AVAILABLE_IOS(8_0);
/** 弹出键盘时附带的视图的视图控制器 */
@property (nullable, nonatomic, readonly, strong) UIInputViewController *inputAccessoryViewController NS_AVAILABLE_IOS(8_0);
 
/** 文本输入模式 */
@property (nullable, nonatomic, readonly, strong) UITextInputMode *textInputMode NS_AVAILABLE_IOS(7_0);
 
/** 文本输入模式标识 */
@property (nullable, nonatomic, readonly, strong) NSString *textInputContextIdentifier NS_AVAILABLE_IOS(7_0);
/** 根据设置的标识清除指定的文本输入模式 */
+ (void)clearTextInputContextIdentifier:(NSString *)identifier NS_AVAILABLE_IOS(7_0);
 
/** 重新刷新键盘输入视图 */
- (void)reloadInputViews NS_AVAILABLE_IOS(3_2);
 
@end
 
/** 特殊快捷辅键定义 */
UIKIT_EXTERN NSString *const UIKeyInputUpArrow         NS_AVAILABLE_IOS(7_0); //!< 上按键.
UIKIT_EXTERN NSString *const UIKeyInputDownArrow       NS_AVAILABLE_IOS(7_0); //!< 下按键.
UIKIT_EXTERN NSString *const UIKeyInputLeftArrow       NS_AVAILABLE_IOS(7_0); //!< 左按键.
UIKIT_EXTERN NSString *const UIKeyInputRightArrow      NS_AVAILABLE_IOS(7_0); //!< 右按键
UIKIT_EXTERN NSString *const UIKeyInputEscape          NS_AVAILABLE_IOS(7_0); //!< Esc按键.
 
#pragma mark - 响应者活动
 
@interface UIResponder (ActivityContinuation)
/** 用户活动 */
@property (nullable, nonatomic, strong) NSUserActivity *userActivity NS_AVAILABLE_IOS(8_0);
/** 更新用户活动 */
- (void)updateUserActivityState:(NSUserActivity *)activity NS_AVAILABLE_IOS(8_0);
/** 恢复用户活动 */
- (void)restoreUserActivityState:(NSUserActivity *)activity NS_AVAILABLE_IOS(8_0);
@end
 
NS_ASSUME_NONNULL_END

9. UIResponder使用Demo

1. 通过响应者链查找视图的视图控制器

/**
 *  查找视图的视图控制器
 *
 *  @param view 视图
 *
 *  @return 返回视图的控制器
 */
- (UIViewController *)getControllerFromView:(UIView *)view {
    // 遍历响应者链。返回第一个找到视图控制器
    UIResponder *responder = view;
    while ((responder = [responder nextResponder])){
        if ([responder isKindOfClass: [UIViewController class]]){
            return (UIViewController *)responder;
        }
    }
    // 如果没有找到则返回nil
    return nil;
}

   通过响应链查找视图控制器，nextResponder获取下一个响应者，响应者顺序为：

2. 设置与取消第一响应者

//
//  FirstResponderView.m
//  ResponderDemo
//
//  Created by VanZhang on 2017/5/12.
//  Copyright © 2017年 . All rights reserved.
//
 
#import "FirstResponderView.h"
 
@implementation FirstResponderView
 
/** 演示设置为第一响应者 */
- (void)setBecomeFirstResponder {
    // 判断对象是否已经是第一响应者
    if ([self isFirstResponder]) {
        return;
    }
    // 判断对象是否允许成为第一响应者
    if ([self canBecomeFirstResponder]) {
        // 设置成为第一响应者
        [self becomeFirstResponder];
    }
}
 
/** 演示放弃第一响应者 */
- (void)setResignFirstResponder {
    // 判断对象是否不是第一响应者
    if (![self isFirstResponder]) {
        return;
    }
    // 判断对象是否允许放弃第一响应者
    if ([self canResignFirstResponder]) {
        // 设置放弃第一响应者
        [self resignFirstResponder];
    }
}
 
/** 重写方法，允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}
 
@end
      UIView默认不允许设置为第一响应者，因此设置UIView为第一响应者需要重写canBecomeFirstResponder方法并返回YES。 设置为第一响应者后，对象则可以接受远程控制事件进行处理（如耳机线控）。 UITextField、UITextView成为第一响应者后会弹出输入键盘，取消第一响应者则会隐藏输入键盘。

3. 触摸相关方法，一般用于响应屏幕触摸

/** 手指按下时响应 */
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event {
    [super touchesBegan:touches withEvent:event];
    NSLog(@"--->手指按下时响应");
}
 
/** 手指移动时响应 */
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event {
    [super touchesMoved:touches withEvent:event];
    NSLog(@"--->手指移动时响应");
}
 
/** 手指抬起时响应 */
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event {
    [super touchesEnded:touches withEvent:event];
    NSLog(@"--->手指抬起时响应");
}
 
/** 触摸取消(意外中断, 如:电话, Home键退出等) */
- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event {
    [super touchesCancelled:touches withEvent:event];
    NSLog(@"--->取消触摸响应");
}

4. 加速相关方法，一般用于摇一摇、运动事件监听等

/** 开始加速 */
- (void)motionBegan:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(3_0) {
    [super motionBegan:motion withEvent:event];
    NSLog(@"--->开始加速");
}
 
/** 结束加速 */
- (void)motionEnded:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(3_0) {
    [super motionEnded:motion withEvent:event];
    NSLog(@"--->结束加速");
}
 
/** 加速取消（意外中断, 如:电话, Home键退出等） */
- (void)motionCancelled:(UIEventSubtype)motion withEvent:(nullable UIEvent *)event NS_AVAILABLE_IOS(3_0) {
    [super motionCancelled:motion withEvent:event];
    NSLog(@"--->加速取消");
}

5. 远程控制方法，一般用于耳机线控


//
//  AudioView.m
//  ResponderDemo
//
//  Created by VanZhang on 2017/5/12.
//  Copyright © 2017年 . All rights reserved.
//
 
#import "AudioView.h"
#import <AVFoundation/AVFoundation.h>
 
@implementation AudioView
 
- (instancetype)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self) {
        // 启动接受远程事件
        [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
        // 设置成为第一响应者
        [self becomeFirstResponder];
        // 播放一段静音文件，使APP获取音频的控制权
        NSURL *audioURL = [NSURL fileURLWithPath:[[NSBundle mainBundle] pathForResource:@"mute_60s" ofType:@"mp3"]];
        AVAudioPlayer *audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:audioURL error:nil];
        [audioPlayer play];
    }
    return self;
}
 
/** 允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}
 
/** 远程控制事件响应 */
- (void)remoteControlReceivedWithEvent:(UIEvent *)receivedEvent {
    NSLog(@"--->耳机线控响应");
}
 
- (void)dealloc {
    // 停止接受远程事件
    [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
    // 放弃第一响应者
    [self resignFirstResponder];
}
 
@end

耳机线控要注意三点要素：

  • （1）启动接受远程事件：[[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
  • （2）设置成为第一响应者（UIViewController，AppDelegate中不需要设置） 
    // 设置成为第一响应者
[self becomeFirstResponder];

/** 允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}
  • （3）获取音频的控制权 
    // 播放一段静音文件，使APP获取音频的控制权
NSURL *audioURL = [NSURL fileURLWithPath:[[NSBundle mainBundle] pathForResource:@"mute_60s" ofType:@"mp3"]];
AVAudioPlayer *audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:audioURL error:nil];
[audioPlayer play];

6、在UILabel中实现长按菜单（复制、粘贴等）

//
//  MenuLabel.m
//  ResponderDemo
//
//
 
#import "MenuLabel.h"
 
@implementation MenuLabel
 
- (instancetype)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self) {
        // 启用用户交互
        self.userInteractionEnabled = YES;
        // 添加长按手势
        UILongPressGestureRecognizer *longPressGesture = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(longPressMenu:)];
        longPressGesture.minimumPressDuration = 0.2;
        [self addGestureRecognizer:longPressGesture];
    }
    return self;
}
 
/** 允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}
 
/** 长按响应 */
- (void)longPressMenu:(UILongPressGestureRecognizer *)sender {
    if (sender.state == UIGestureRecognizerStateBegan) {
        // 设置成为第一响应者
        [self becomeFirstResponder];
        // 显示菜单
        UIMenuController *menuCtrl = [UIMenuController sharedMenuController];
        [menuCtrl setTargetRect:self.frame inView:self.superview];
        [menuCtrl setMenuVisible:YES animated:YES];
    }
}
 
/** 返回需要显示的菜单按钮 */
- (BOOL)canPerformAction:(SEL)action withSender:(id)sender {
    // 只显示复制、粘贴按钮
    if (action == @selector(copy:) || action == @selector(paste:)) {
        return YES;
    }
    return NO;
}
 
/** 实现复制方法 */
- (void)copy:(id)sender {
    UIPasteboard *paste = [UIPasteboard generalPasteboard];
    paste.string = self.text;
}
 
/** 实现粘贴方法 */
- (void)paste:(id)sender {
    UIPasteboard *paste = [UIPasteboard generalPasteboard];
    self.text = paste.string;
}
 
@end

为UILabel添加长按菜单需要注意几点：

  • （1）启用用户交互：self.userInteractionEnabled = YES;
  • （2）在显示菜单之前设置对象成为第一响应者（UIViewController，AppDelegate中不需要设置） 
    /** 允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}

// 设置成为第一响应者
[self becomeFirstResponder];

-（3）返回菜单需要显示的按钮，并重写实现对应方法 ```objc

/** 返回需要显示的菜单按钮 */
- (BOOL)canPerformAction:(SEL)action withSender:(id)sender {
    // 只显示复制、粘贴按钮
    if (action == @selector(copy:) || action == @selector(paste:)) {
        return YES;
    }
    return NO;
}

/** 实现复制方法 */
- (void)copy:(id)sender {
    UIPasteboard *paste = [UIPasteboard generalPasteboard];
    paste.string = self.text;
}

/** 实现粘贴方法 */
- (void)paste:(id)sender {
    UIPasteboard *paste = [UIPasteboard generalPasteboard];
    self.text = paste.string;
}
```
  • （4）注册长按手势，显示菜单 
    // 添加长按手势
UILongPressGestureRecognizer *longPressGesture = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(longPressMenu:)];
longPressGesture.minimumPressDuration = 0.2;
[self addGestureRecognizer:longPressGesture];

/** 长按响应 */
- (void)longPressMenu:(UILongPressGestureRecognizer *)sender {
    if (sender.state == UIGestureRecognizerStateBegan) {
        // 设置成为第一响应者
        [self becomeFirstResponder];
        // 显示菜单
        UIMenuController *menuCtrl = [UIMenuController sharedMenuController];
        [menuCtrl setTargetRect:self.frame inView:self.superview];
        [menuCtrl setMenuVisible:YES animated:YES];
    }
}

7、使用NSUndoManager实现画板撤销/重做功能

/** ==============DrawingBoardView.h文件=================== */
 
#import <UIKit/UIKit.h>
 
/** 画板View */
@interface DrawingBoardView : UIView
 
@end
 
 
/** 划线Model */
@interface LineModel : NSObject
 
@property (nonatomic) CGPoint begin;
@property (nonatomic) CGPoint end;
 
@end
 
 
/** ==============DrawingBoardView.m文件=================== */
 
#import "DrawingBoardView.h"
 
/** 画板View */
@interface DrawingBoardView ()
 
@property (nonatomic, strong) LineModel *currentLine;
@property (nonatomic, strong) NSMutableArray<LineModel *> *toucheArray;
 
@end
 
@implementation DrawingBoardView
 
 
- (instancetype)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self) {
        [self initSubView];
        self.backgroundColor = [UIColor whiteColor];
        self.toucheArray = [NSMutableArray array];
    }
    return self;
}
 
/** 绘制画板 */
- (void)drawRect:(CGRect)rect {
    // 获得上下文
    CGContextRef context = UIGraphicsGetCurrentContext();
    // 设置样式
    CGContextSetLineCap(context, kCGLineCapSquare);
    // 设置宽度
    CGContextSetLineWidth(context, 5.0);
    // 设置颜色
    CGContextSetStrokeColorWithColor(context, [[UIColor redColor] CGColor]);
    
    for (LineModel *line in self.toucheArray) {
        // 开始绘制
        CGContextBeginPath(context);
        // 移动画笔到起点
        CGContextMoveToPoint(context, line.begin.x, line.begin.y);
        // 添加下一点
        CGContextAddLineToPoint(context, line.end.x, line.end.y);
        // 绘制完成
        CGContextStrokePath(context);
    }
}
 
/** 划线开始 */
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    // 标记开始撤销分组
    [self.undoManager beginUndoGrouping];
    
    for (UITouch *touch in touches) {
        // 记录起始点
        CGPoint locTouch = [touch locationInView:self];
        _currentLine = [[LineModel alloc] init];
        _currentLine.begin = locTouch;
        _currentLine.end = locTouch;
    }
    
}
 
/** 划线移动 */
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    for (UITouch *touch in touches) {
        // 添加线条
        CGPoint locTouch = [touch locationInView:self];
        _currentLine.end = locTouch;
        [self addLine:_currentLine];
        // 当前线条
        _currentLine = [[LineModel alloc] init];
        _currentLine.begin = locTouch;
        _currentLine.end = locTouch;
    }
}
 
/** 划线结束 */
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
    // 结束标记撤销分组
    [self.undoManager endUndoGrouping];
}
 
/** 添加划线 */
- (void)addLine:(LineModel *)line
{
    // 添加划线并重绘画板
    [self.toucheArray addObject:line];
    [self setNeedsDisplay];
    // 注册撤销方法
    [[self.undoManager prepareWithInvocationTarget:self] removeLine:line];
}
 
/** 移除划线 */
- (void)removeLine:(LineModel *)line
{
    if ([self.toucheArray containsObject:line]) {
        // 移除划线并重绘画板
        [self.toucheArray removeObject:line];
        [self setNeedsDisplay];
        // 注册撤销方法
        [[self.undoManager prepareWithInvocationTarget:self] addLine:line];
    }
}
 
/** 撤销按钮点击响应 */
- (void)undoButtonAction:(id)sender {
    if ([self.undoManager canUndo]) {
        [self.undoManager undo];
    }
}
 
/** 重做按钮点击响应 */
- (void)redoButtonAction:(id)sender {
    if ([self.undoManager canRedo]) {
        [self.undoManager redo];
    }
}
 
/** 初始化子控件 */
- (void)initSubView {
    // 撤销按钮
    UIButton *undoButton = [UIButton buttonWithType:UIButtonTypeSystem];
    undoButton.frame = CGRectMake(0, 64, 70, 50);
    [undoButton setTitle:@"undo撤销" forState:UIControlStateNormal];
    [undoButton sizeToFit];
    [undoButton addTarget:self action:@selector(undoButtonAction:) forControlEvents:UIControlEventTouchUpInside];
    [self addSubview:undoButton];
    // 重做按钮
    UIButton *redoButton = [UIButton buttonWithType:UIButtonTypeSystem];
    redoButton.frame = CGRectMake(CGRectGetWidth(self.frame)-70, 64, 70, 50);
    [redoButton setTitle:@"redo重做" forState:UIControlStateNormal];
    [redoButton sizeToFit];
    [redoButton addTarget:self action:@selector(redoButtonAction:) forControlEvents:UIControlEventTouchUpInside];
    [self addSubview:redoButton];
}
 
@end

实现撤销/重做注意以下几点：

  • （1）在调用方法时需要添加注册一个对应的撤销方法 
    // 注册撤销方法
[[self.undoManager prepareWithInvocationTarget:self] removeLine:line];
  • （2）撤销/ 重做只需要调用undoManager中的相应方法即可 
        /** 撤销按钮点击响应 */
    - (void)undoButtonAction:(id)sender {
        if ([self.undoManager canUndo]) {
            [self.undoManager undo];
        }
    }

    /** 重做按钮点击响应 */
    - (void)redoButtonAction:(id)sender {
        if ([self.undoManager canRedo]) {
            [self.undoManager redo];
        }
    }
  • （3）如果需要多个动作一起撤销则需要标记分组 
       // 标记开始撤销分组
    [self.undoManager beginUndoGrouping];
    // 结束标记撤销分组
    [self.undoManager endUndoGrouping];

8、自定义快捷键

//
//  KeyCommandView.m
//  ResponderDemo
//
//  Created by VanZhang on 2017/5/17.
//  Copyright © 2017年 . All rights reserved.
//
 
#import "KeyCommandView.h"
 
@implementation KeyCommandView
 
- (instancetype)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self) {
        // 设置成为第一响应者
        [self becomeFirstResponder];
    }
    return self;
}
 
/** 允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}
 
/** 返回快捷命令数组 */
-(NSArray<UIKeyCommand *> *)keyCommands {
    return @[
             [UIKeyCommand keyCommandWithInput:UIKeyInputEscape modifierFlags:UIKeyModifierShift action:@selector(pressedShiftAndEscapeKey:) discoverabilityTitle:@"自定义[Shift+Esc]快捷键"],
             [UIKeyCommand keyCommandWithInput:@"a" modifierFlags:UIKeyModifierShift action:@selector(pressedShiftAndAKey:) discoverabilityTitle:@"自定义[Shift+A]快捷键"]
             ];
}
 
/** Shift+Esc快捷命令响应 */
-(void)pressedShiftAndEscapeKey:(UIKeyCommand *)keyCommand {
    UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:keyCommand.discoverabilityTitle message:[NSString stringWithFormat:@"按下快捷辅键:[%@]", keyCommand.input] delegate:nil cancelButtonTitle:@"确定" otherButtonTitles:nil];
    [alertView show];
}
 
/** Shift+A快捷命令响应 */
-(void)pressedShiftAndAKey:(UIKeyCommand *)keyCommand {
    UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:keyCommand.discoverabilityTitle message:[NSString stringWithFormat:@"按下快捷辅键:[%@]", keyCommand.input] delegate:nil cancelButtonTitle:@"确定" otherButtonTitles:nil];
    [alertView show];
}
 
@end
自定义快捷键需要注意两点：
（1）设置对象成为第一响应者（UIViewController，AppDelegate中不需要设置）

// 设置成为第一响应者
[self becomeFirstResponder];
 
/** 允许对象成为第一响应者 */
- (BOOL)canBecomeFirstResponder {
    return YES;
}
（2）重写 keyCommands 返回快捷命令组合
/** 返回快捷命令数组 */
-(NSArray<UIKeyCommand *> *)keyCommands {
    return @[
             [UIKeyCommand keyCommandWithInput:UIKeyInputEscape modifierFlags:UIKeyModifierShift action:@selector(pressedShiftAndEscapeKey:) discoverabilityTitle:@"自定义[Shift+Esc]快捷键"],
             [UIKeyCommand keyCommandWithInput:@"a" modifierFlags:UIKeyModifierShift action:@selector(pressedShiftAndAKey:) discoverabilityTitle:@"自定义[Shift+A]快捷键"]
             ];
}

9、自定义UITextField输入键盘

//
//  CustomInputView.m
//  ResponderDemo
//
//  Created by VanZhang on 2017/5/18.
//  Copyright © 2017年 . All rights reserved.
//
 
#import "CustomInputView.h"
 
#define MAIN_SCREEN_WIDTH [[UIScreen mainScreen] bounds].size.width   //!< 屏幕的Width
 
@interface CustomInputView ()
 
@property (nonatomic, strong) UITextField *textField;
@property (nonatomic, strong) UIView *customInputView;
@property (nonatomic, strong) UIToolbar *customAccessoryView;
 
@end
 
@implementation CustomInputView
 
- (instancetype)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self) {
        // 添加TextField
        [self addSubview:self.textField];
    }
    return self;
}
 
/** 懒加载textField */
- (UITextField *)textField {
    if (!_textField) {
        // 初始化textField
        _textField = [[UITextField alloc]initWithFrame:CGRectMake(50, 100, MAIN_SCREEN_WIDTH - 100, 30)];
        _textField.borderStyle = UITextBorderStyleRoundedRect;
        _textField.placeholder = @"测试";
        // 设置自定义键盘View
        _textField.inputView = self.customInputView;
        _textField.inputAccessoryView = self.customAccessoryView;
    }
    return _textField;
}
 
/** 懒加载customInputView */
- (UIView *)customInputView {
    if (!_customInputView) {
        _customInputView = [[UIView alloc]initWithFrame:CGRectMake(0, 0, MAIN_SCREEN_WIDTH, 220)];
        _customInputView.backgroundColor = [UIColor lightGrayColor];
        UILabel *label = [[UILabel alloc]initWithFrame:CGRectMake(0, 100, MAIN_SCREEN_WIDTH, 40)];
        label.textAlignment = NSTextAlignmentCenter;
        label.text = @"自定义inputView";
        [_customInputView addSubview:label];
    }
    return _customInputView;
}
 
/** 懒加载customAccessoryView */
- (UIToolbar *)customAccessoryView {
    if (!_customAccessoryView) {
        _customAccessoryView = [[UIToolbar alloc]initWithFrame:CGRectMake(0, 0, MAIN_SCREEN_WIDTH, 40)];
        _customAccessoryView.barTintColor = [UIColor orangeColor];
        UIBarButtonItem *space = [[UIBarButtonItem alloc]initWithBarButtonSystemItem:UIBarButtonSystemItemFlexibleSpace target:nil action:nil];
        UIBarButtonItem *done = [[UIBarButtonItem alloc]initWithTitle:@"完成" style:UIBarButtonItemStyleDone target:self action:@selector(done)];
        [_customAccessoryView setItems:@[space, space, done]];
    }
    return _customAccessoryView;
}
 
/** 响应完成按钮 */
- (void)done {
    [self.textField resignFirstResponder];
}
 
 
@end

六、UIApplication

UIApplication 是iOS应用程序的核心类之一，承担着管理应用程序生命周期、事件处理和应用程序级别操作的重要角色，为应用程序的正常运行和用户体验提供了基础支持。

以下是UIApplication的简介:

  • UIApplication对象是应用程序的象征
  • 利用UIApplication对象能进行一些应用级别的操作
  • 每一个应用程序都有自己的第一个UI对象就是UIApplication对象。
  • 通过UIApplication *app = [UIApplication sharedApplication];可以获得这个单例对象。

1. UIApplication对象的创建时机

那么UIApplication对象是什么时候被创建的呢？
我们找到程序的入口main.m 阅读 main 函数

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

我们发现程序一开始调用了UIApplicationMain方法，并且还有4个参数:

  • argc

    The count of arguments in argv; this usually is the corresponding parameter to main.

  • argv

    A variable list of arguments; this usually is the corresponding parameter to main.

  • principalClassName

    The name of the UIApplication class or subclass. If you specify nil, UIApplication is assumed.

  • delegateClassName

    The name of the class from which the application delegate is instantiated. If principalClassName designates a subclass of UIApplication, you may designate the subclass as the delegate; the subclass instance receives the application-delegate messages. Specify nil if you load the delegate object from your application’s main nib file.

  • argc:系统或者用户传入的参数
  • argv:系统或用户传入的实际参数 重点放在第三、四个参数
  • 第三个参数 nil:代表UIApplication类名或者子类名称，nil 相当于 @"UIApplicaiton";
  • 第四个参数:代表UIApplicaiton的代理名称 NSStringFromClass([AppDelegate class] 相当于 @"AppDelegate";

2. 了解应用程序启动的过程

此时我们可以根据UIApplicationMain函数了解程序启动的过程:

根据传递的类名创建UIApplication对象，这是第一个对象 2. 创建UIApplication代理对象，并给UIApplicaiton对象设置代理

  1. 开启主线程运行循环 main events loop处理事件，保持程序一直运行
  2. 加载info.plist,判断是否指定mian(xib 或者 storyboard)如果指定就去加载
  3. ...

3. AppDelegate回调方法

在创建UIApplication代理对象，并给UIApplicaiton对象设置代理AppDelegate之后,UIApplication 对应用级事件的管理就通过遵守了UIApplicationDelegate协议的代理对象AppDelegate的回调来分发出去。

因此,我们应该对 UIApplicationDelegate协议 中的常用回调方法有所了解:

AppDelegate的回调方法:

3.1 App初始化:

application(_:willFinishLaunchingWithOptions:): * 当应用程序即将完成启动过程时调用，但在应用程序界面显示之前。 * 可以在此方法中进行应用程序的初始化设置和准备工作。 2. application(_:didFinishLaunchingWithOptions:): * 当应用程序完成启动过程时调用，此时应用程序已经准备好显示界面。 * 可以在此方法中进行应用程序的最终设置和准备工作。

对应的通知的名称:

3.2 应用程序生命周期管理:

UIApplication 负责管理应用程序的生命周期，包括应用程序的启动、运行、进入后台、恢复等阶段:

applicationDidBecomeActive(_:): * 当应用程序从后台切换到前台并变为活动状态时调用。 * 可以在此方法中恢复应用程序的运行状态和处理需要立即执行的任务。 2. applicationWillResignActive(_:): * 当应用程序将要从活动状态切换到非活动状态时调用，如来电、弹出系统警告等情况。 * 可以在此方法中暂停应用程序的运行状态和处理需要延迟执行的任务。 3. applicationDidEnterBackground(_:): * 当应用程序进入后台运行时调用，通常在此方法中保存应用程序的状态和数据。 * 可以在此方法中执行一些后台任务和清理操作。 4. applicationWillEnterForeground(_:): * 当应用程序即将从后台切换到前台时调用，通常在此方法中恢复应用程序的状态和数据。 * 可以在此方法中执行一些前台准备工作和更新界面操作。 5. applicationWillTerminate(_:): * 当应用程序即将终止时调用，通常在此方法中保存应用程序的最终状态和数据。 * 可以在此方法中执行一些清理操作和释放资源。

对应的通知的名称:

3.3 远程通知事件:

3.4 快捷操作QuickAction和用户活动UserActivity:

3.5 WatchKit交互

3.6 HealthKit交互

3.7 Opening a URL-specified resource

3.8 SiriKit事件处理

3.9 CloudKit事件处理

3.10 内存警告等系统环境变化回调

4. 应用级事件处理

官方介绍UIApplication

  • 应用程序生命周期管理:
    • shared:返回单例的UIApplication对象，用于获取应用程序的全局状态。
    • delegate:设置或获取应用程序的委托对象，通常为实现UIApplicationDelegate协议的对象。
  • 应用程序状态获取:
    • applicationState:获取当前应用程序的状态，包括活动状态、后台状态和挂起状态。 应用程序操作:
    • openURL(_:options:completionHandler:):通过指定的URL打开其他应用程序或执行其他操作。
    • canOpenURL(_:):检查是否可以通过指定的URL打开其他应用程序。
  • 通知注册:
    • registerForRemoteNotifications():注册接收远程通知。
    • unregisterForRemoteNotifications():取消接收远程通知的注册。
  • 本地通知:
    • presentLocalNotificationNow(_:):立即显示本地通知。
    • scheduleLocalNotification(_:):定时显示本地通知。
  • 应用程序图标角标:
    • applicationIconBadgeNumber:获取或设置应用程序图标的角标数字。 状态栏控制:
    • statusBarStyle:获取或设置状态栏的样式。
    • setStatusBarHidden(_:with:):显示或隐藏状态栏。
  • 应用程序退出:
    • terminate():退出应用程序。
  • 应用程序间跳转:
    • open(_:options:completionHandler:):通过指定的URL启动或跳转到其他应用程序。
    • open(_:options:completionHandler:):通过指定的URL启动或跳转到其他应用程序。
  • 系统声音与震动:
    • beginBackgroundTask(withName:expirationHandler:):开始后台任务，延长应用程序在后台运行的时间。
    • endBackgroundTask(_:):结束后台任务。
  • 远程控制:
    • beginReceivingRemoteControlEvents():开始接收远程控制事件。
    • endReceivingRemoteControlEvents():结束接收远程控制事件。
  • 应用程序状态保存和恢复:
    • beginBackgroundTask(withName:expirationHandler:):开始后台任务，延长应用程序在后台运行的时间。
    • endBackgroundTask(_:):结束后台任务。

5. 代码示例:

  • 设置应用程序图标右上角的红色提醒数字
    @property(nonatomic) NSInteger applicationIconBadgeNumber;

        UIApplication *app = [UIApplication sharedApplication];
    app.applicationIconBadgeNumber = 10;
    // 创建通知对象
    UIUserNotificationSettings *setting = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeBadge categories:nil];
    // 注册用户通知
    [app registerUserNotificationSettings:setting];

    注：苹果为了增强用户体验，在iOS8以后我们需要创建通知才能实现图标右上角提醒，iOS8之前直接设置applicationIconBadgeNumber的值即可。

  • 设置联网指示器的可见性
    @property(nonatomic,getter=isNetworkActivityIndicatorVisible) BOOL networkActivityIndicatorVisible;

    app.networkActivityIndicatorVisible= YES;

  • 管理状态栏
    从iOS7开始，系统提供了2种管理状态栏的方式
    a.通过UIViewController管理（每一个UIViewController都可以拥有自己不同的状态栏）在iOS7中，默认情况下，状态栏都是由UIViewController管理的，UIViewController实现下列方法就可以轻松管理状态栏的可见性和样式
    状态栏的样式　　 - (UIStatusBarStyle)preferredStatusBarStyle;
    状态栏的可见性　　-(BOOL)prefersStatusBarHidden;

    #pragma mark-设置状态栏的样式
-(UIStatusBarStyle)preferredStatusBarStyle {
  //设置为白色
  //return UIStatusBarStyleLightContent;
  //默认为黑色
   return UIStatusBarStyleDefault;
}
#pragma mark-设置状态栏是否隐藏（否）
-(BOOL)prefersStatusBarHidden {
  return NO;
}

    b.通过UIApplication管理（一个应用程序的状态栏都由它统一管理）如果想利用UIApplication来管理状态栏，首先得修改Info.plist的设置，添加选中行，并将NO改为YES，这篇文章中有详细介绍iOS中用application 来管理电池栏状态
    Info.plist的设置: 

    //通过sharedApplication获取该程序的UIApplication对象
UIApplication *app=[UIApplication sharedApplication];
//设置状态栏的样式
//app.statusBarStyle=UIStatusBarStyleDefault;//默认（黑色）
//设置为白色+动画效果
[app setStatusBarStyle:UIStatusBarStyleLightContent animated:YES];
//设置状态栏是否隐藏
app.statusBarHidden=YES;
//设置状态栏是否隐藏+动画效果
[app setStatusBarHidden:YES withAnimation:UIStatusBarAnimationFade];

    c.总结

    如果状态栏的样式只设置一次，那就用UIApplication来进行管理，并且UIApplication可以提供动画效果；
    如果状态栏是否隐藏，样式不一那就用每个控制器对自己的状态栏进行管理。

  • openURL:方法
    UIApplication有个功能十分强大的openURL:方法
    - (BOOL)openURL:(NSURL*)url;
    openURL:方法的部分功能有

            UIApplication *app = [UIApplicationsharedApplication];
        打电话  [app openURL:[NSURLURLWithString:@"tel://110"]];
        发短信  [app openURL:[NSURLURLWithString:@"sms://10086"]];
        发邮件  [app openURL:[NSURLURLWithString:@"mailto://xxcc@fox.com"]];
        打开一个网页资源 [app openURL:[NSURL URLWithString:@"http://www.baidu.com"]];
        打开其他app程序   openURL方法，可以打开其他APP。

    系统内部根据不同的头标示来做出不同的相应。

  • 判断程序运行状态

      //判断程序运行状态
  /*
   UIApplicationStateActive, 
   UIApplicationStateInactive, 
   UIApplicationStateBackground
   */
UIApplication *app = [UIApplication sharedApplication];
if(app.applicationState ==UIApplicationStateInactive){
      NSLog(@"程序在运行状态");
  }

  • 阻止屏幕变暗进入休眠状态

     //阻止屏幕变暗，慎重使用本功能，因为非常耗电。
 UIApplication *app = [UIApplication sharedApplication];
 app.idleTimerDisabled =YES;

01-iOS 多媒体技术| 图形处理框架简介:Core Animation、Core Graphics、OpenGL ES、Metal、GPUImage等

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

前言

多媒体技术 包括 视觉图形处理、音频视频处理、XR技术（AR、VR）等。都是有趣且富有含金量的技术实践方向。
本篇文章是 iOS 视觉图形处理 技术核心框架简介，为我们快速了解 iOS 视觉图形 技术，以便于在项目实战中进行技术选型、为提升自己在图形学上的技术能力指明方向,为后期我们在图形学方面的项目实践在某一个点的深入埋下伏笔。

我们在探索 iOS 图层渲染原理的时候,对 iOS 各个渲染框架 和 渲染技术栈 做了相关探索,

1. iOS的各个渲染框架

在介绍渲染框架之前,我们得先了解一下iOS系统的渲染流水和具体的渲染技术栈

1.渲染技术栈

iOS 的渲染框架依然符合渲染流水线的基本架构，具体的技术栈如上图所示

  • 在硬件基础之上，iOS 中有 Core Graphics、Core Animation、Core Image、OpenGL 等多种软件框架来绘制内容，在 CPU 与 GPU 之间进行了更高层地封装

一、iOS图像处理相关框架汇总

1. 苹果系统自带的框架：

  • 图形界面 UIKit
  • 核心动画 Core Animation
    • 主要在GPU上工作，用于动画效果和图层管理
  • 2D图形绘制和渲染 Core Graphics（Quartz 2D）
    • 主要在CPU上工作，用于2D图形绘制和渲染
  • 图像处理和滤镜 Core Image
    • 主要在GPU上工作，用于图像处理和滤镜效果
  • 图形渲染和计算 Metal
    • 主要在GPU上工作，用于高性能图形渲染和计算
  • 游戏引擎
    • Scene Kit (3D)
    • Sprite Kit (2D)

2. 优秀的第三方库:

  • 滤镜处理 GPUImage
    • 主要在GPU上工作,提供了丰富的图像处理和滤镜功能
  • 计算机视觉 OpenCV
    • 主要在CPU上工作,用于计算机视觉和图像处理
  • 跨平台图形框架 OpenGL ES
    • 主要在GPU上工作,用于实现3D图形渲染和游戏开发

毫无疑问，开发者们接触得最多的框架是以下几个，UIKit、Core Animation，Core Graphic, Core Image。下面简要介绍这几个框架,顺便介绍下GPUImage:

二、UIKit框架

1. UIKit框架简介

UIKit是iOS应用程序开发的基础框架之一，也是iOS开发中的一个核心框架。它提供了一系列的类和组件,通过UIKit，开发者可以快速构建各种界面元素、实现用户交互和动画效果.

UIKit的主要功能和组件:

  • 视图（View）:用于构建应用程序的用户界面，包括
    • 基本视图
    • 容器视图
    • 表视图
    • 集合视图
    • ...
  • 控件（Control）:提供了各种用户交互控件，如:
    • 按钮、标签、文本框、滑块等
  • 视图控制器（View Controller）:用于管理视图的显示和交互，包括:
    • UIViewController、UINavigationController、UITabBarController等。
  • 动画（Animation）：提供了动画效果的支持，如:
    • 视图动画、过渡动画、关键帧动画等。
  • 手势识别（Gesture Recognizer）: 用于识别和处理用户手势操作,如:
    • 点击、滑动、捏合等。
  • 绘图（Drawing）：提供了绘制图形和文本的功能，如:
    • 绘制形状、渲染文本、处理图形上下文等。
      • 1. 绘制形状:
        • 使用UIBezierPath类可以绘制各种形状，如直线、曲线、矩形、圆角矩形、椭圆等。
        • 通过设置路径的属性（如线宽、颜色、填充等）可以定制绘制效果。
      • 2. 绘制文本:
        • 使用NSString和NSAttributedString类可以绘制文本内容。
        • 通过UILabel、UITextView等控件可以显示文本内容，也可以通过Core Text框架实现更复杂的文本排版效果。
      • 3. 绘制图像:
        • 使用UIImage类可以加载和显示图像。
        • 通过UIImageView控件可以显示图像，也可以通过Core Graphics框架实现图像的绘制和处理。
      • 4. 绘制图形上下文:
        • 使用UIGraphicsBeginImageContextWithOptions函数可以创建一个图形上下文。
        • 在图形上下文中可以进行绘制操作，如绘制形状、文本、图像等。
        • 使用UIGraphicsGetImageFromCurrentImageContext函数可以获取绘制的图像。
      • 5. 绘制动画:
        • 使用UIView的动画方法（如animateWithDuration:animations:）可以实现简单的视图动画效果。
        • 通过Core Animation框架可以实现更复杂的动画效果，如关键帧动画、过渡动画等。
      • 6. 绘制路径：
        • 使用UIBezierPath类可以创建和操作路径对象，实现复杂的路径绘制和操作。
        • 通过CAShapeLayer图层可以将路径添加到视图中进行显示。
  • 文本排版（Text Layout）:支持文本的排版和显示，包括文本样式、字体、段落样式等。
  • 多任务处理（Multitasking）: 支持应用程序在多任务环境下的处理和适配。
    • 1. 多任务处理模式：
      • 前台模式：应用程序在前台运行，响应用户交互和显示界面。
      • 后台模式：应用程序在后台运行，执行一些特定的任务，如音频播放、位置更新等。
      • 多任务处理：应用程序可以同时执行多个任务，如下载数据、处理网络请求等。
    • 2. 多任务处理功能：
      • 后台执行任务：通过使用后台任务、后台会话等机制，应用程序可以在后台执行一些任务，如下载、上传数据等。
      • 多线程处理：通过使用GCD（Grand Central Dispatch）和Operation Queue等多线程技术，应用程序可以在多个线程上执行并发任务，提高性能和响应速度。
      • 多任务处理状态管理：应用程序可以通过UIApplication类的状态变化通知来管理多任务处理状态，如进入后台、恢复前台等。
    • 3. 多任务处理场景：
      • 音频播放：应用程序可以在后台继续播放音频。
      • 位置更新：应用程序可以在后台更新位置信息。
      • 网络请求：应用程序可以在后台执行网络请求和数据下载。
      • 数据处理：应用程序可以在后台处理数据、计算等任务。
  • 其它:
    • 一些类: UIColor（颜色操作）、UIFont和UIScreen（提供字体和屏幕信息)

2. UIKit与Core Graphics的关系:

UIKit的绘图功能主要用于实现简单的图形绘制、文本显示和图像处理，适用于构建基本的用户界面元素和视图效果。
对于更复杂的绘图需求,可以结合Core Graphics框架来实现更丰富用户界面和图形效果

以下是UIKit与Core Graphics结合使用的一些常见场景和方法:

  • 1. 绘制自定义视图:
    • 可以通过继承UIView类，并重写drawRect方法，在其中使用Core Graphics绘制自定义的图形、文本或图像。
    • 在drawRect方法中，可以创建UIBezierPath对象、设置绘制属性（如颜色、线宽等），并调用Core Graphics的绘制方法来实现自定义绘制效果。
  • 2. 绘制图形和文本:
    • 使用UIKit提供的控件和视图来构建用户界面，同时可以使用Core Graphics来实现一些特殊的绘制效果，如渐变背景、阴影效果等。
    • 通过Core Graphics的文本绘制功能，可以实现更灵活的文本排版和样式设置。
  • 3. 图形上下文的管理:
    • 可以通过UIGraphicsGetCurrentContext函数获取当前的图形上下文，然后使用Core Graphics在该上下文中进行绘制操作。
    • 在绘制过程中，可以使用UIGraphicsPushContext和UIGraphicsPopContext函数来管理图形上下文的压栈和出栈。
  • 4. 图形动画效果:
    • 可以结合UIKit的动画方法和Core Graphics的绘制功能，实现一些复杂的图形动画效果。
    • 通过UIView的动画方法和Core Graphics的绘制方法结合使用，可以实现视图的平滑过渡和动态效果。
  • 5. 图形处理和滤镜效果:
    • 可以使用Core Graphics对图像进行处理，如裁剪、缩放、旋转等操作。
    • 结合Core Image框架，可以实现更复杂的图像处理和滤镜效果，为用户界面增加更多的视觉效果。

3. 代码示例:

在UIKit中，UIView类本身在绘制时自动创建一个图形环境，即Core Graphics层的CGContext类型，作为当前的图形绘制环境。
在绘制时可以调用 UIGraphicsGetCurrentContext 函数获得当前的图形环境;

3.1 绘制自定义视图|绘制路径:

Objective-C示例:

//这段代码就是在UIView的子类中调用 UIGraphicsGetCurrentContext 函数获得当前的图形环境，然后向该图形环境添加路径，最后绘制。
- (void)drawRect:(CGRect)rect {
      //1.获取上下文
      CGContextRef contextRef = UIGraphicsGetCurrentContext();
      //2.描述路径
      UIBezierPath * path = [UIBezierPath bezierPath];
      //起点
      [path moveToPoint:CGPointMake(10, 10)];
      //终点
      [path addLineToPoint:CGPointMake(100, 100)];
      //设置颜色
      [[UIColor whiteColor]setStroke];
      //3.添加路径
      CGContextAddPath(contextRef, path.CGPath);
      //显示路径
      CGContextStrokePath(contextRef);
}
// Objective-C 代码示例：

// CustomView.h
#import <UIKit/UIKit.h>

@interface CustomView : UIView

@end

// CustomView.m
#import "CustomView.h"

@implementation CustomView

- (void)drawRect:(CGRect)rect {
      //1.获取上下文
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    // 绘制路径
    CGContextSetStrokeColorWithColor(context, [UIColor redColor].CGColor);
    CGContextSetLineWidth(context, 2.0);
    CGContextMoveToPoint(context, 50, 50);
    CGContextAddLineToPoint(context, 200, 200);
    CGContextStrokePath(context);
}

@end

Swift示例:

// Swift 代码示例
// CustomView.swift
import UIKit

class CustomView: UIView {

    override func draw(_ rect: CGRect) {
        if let context = UIGraphicsGetCurrentContext() {
            let path = UIBezierPath()
            path.move(to: CGPoint(x: 50, y: 50))
            path.addLine(to: CGPoint(x: 150, y: 150))
            path.addArc(withCenter: CGPoint(x: 100, y: 100), radius: 50, startAngle: 0, endAngle: CGFloat(Double.pi * 2), clockwise: true)
            
            context.setStrokeColor(UIColor.red.cgColor)
            context.setLineWidth(2.0)
            
            context.addPath(path.cgPath)
            context.strokePath()
        }
    }
}

3.2 绘制自定义视图|绘制形状、文本等:

Objective-C示例:

// CustomView.h
#import <UIKit/UIKit.h>

@interface CustomView : UIView

@end

// CustomView.m
#import "CustomView.h"

@implementation CustomView

- (void)drawRect:(CGRect)rect {
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    // 绘制矩形
    CGContextSetFillColorWithColor(context, [UIColor blueColor].CGColor);
    CGContextFillRect(context, CGRectMake(50, 50, 100, 100));
    
    // 绘制圆形
    CGContextSetFillColorWithColor(context, [UIColor redColor].CGColor);
    CGContextFillEllipseInRect(context, CGRectMake(150, 150, 50, 50));
    
    // 绘制文本
    NSString *text = @"Hello, Core Graphics!";
    [text drawAtPoint:CGPointMake(50, 200) withAttributes:@{NSFontAttributeName: [UIFont systemFontOfSize:16], NSForegroundColorAttributeName: [UIColor greenColor]}];
}

@end

Swift示例:

// CustomView.swift
import UIKit

class CustomView: UIView {
    
    override func draw(_ rect: CGRect) {
        if let context = UIGraphicsGetCurrentContext() {
            // 绘制矩形
            context.setFillColor(UIColor.blue.cgColor)
            context.fill(CGRect(x: 50, y: 50, width: 100, height: 100))
            
            // 绘制圆形
            context.setFillColor(UIColor.red.cgColor)
            context.fillEllipse(in: CGRect(x: 150, y: 150, width: 50, height: 50))
            
            // 绘制文本
            let text = "Hello, Core Graphics!"
            let attributes: [NSAttributedString.Key: Any] = [NSAttributedString.Key.font: UIFont.systemFont(ofSize: 16), NSAttributedString.Key.foregroundColor: UIColor.green]
            text.draw(at: CGPoint(x: 50, y: 200), withAttributes: attributes)
        }
    }
}

3.3 创建自定义按钮:

Objective-C示例:

// Objective-C示例：
// CustomButton.h
#import <UIKit/UIKit.h>

@interface CustomButton : UIButton

@end

// CustomButton.m
#import "CustomButton.h"

@implementation CustomButton

- (void)drawRect:(CGRect)rect {
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    // 绘制背景
    CGContextSetFillColorWithColor(context, [UIColor blueColor].CGColor);
    CGContextFillRect(context, rect);
    
    // 绘制边框
    CGContextSetStrokeColorWithColor(context, [UIColor whiteColor].CGColor);
    CGContextStrokeRect(context, rect);
    
    // 绘制文本
    NSString *text = @"Custom Button";
    NSDictionary *attributes = @{ NSFontAttributeName: [UIFont systemFontOfSize:16.0], NSForegroundColorAttributeName: [UIColor whiteColor] };
    CGSize textSize = [text sizeWithAttributes:attributes];
    CGPoint textOrigin = CGPointMake((CGRectGetWidth(rect) - textSize.width) / 2, (CGRectGetHeight(rect) - textSize.height) / 2);
    [text drawAtPoint:textOrigin withAttributes:attributes];
}

@end

Swift示例:

// Swift示例：
// CustomButton.swift
import UIKit

class CustomButton: UIButton {
    
    override func draw(_ rect: CGRect) {
        if let context = UIGraphicsGetCurrentContext() {
            // 绘制背景
            context.setFillColor(UIColor.blue.cgColor)
            context.fill(rect)
            
            // 绘制边框
            context.setStrokeColor(UIColor.white.cgColor)
            context.stroke(rect)
            
            // 绘制文本
            let text = "Custom Button"
            let attributes = [NSAttributedString.Key.font: UIFont.systemFont(ofSize: 16.0), NSAttributedString.Key.foregroundColor: UIColor.white]
            let textSize = text.size(withAttributes: attributes)
            let textOrigin = CGPoint(x: (rect.width - textSize.width) / 2, y: (rect.height - textSize.height) / 2)
            text.draw(at: textOrigin, withAttributes: attributes)
        }
    }
}

3.4 绘制图像和文本:

Objective-C示例:

// Objective-C示例：
// 在UIView的drawRect方法中结合Core Graphics绘制图像和文本

- (void)drawRect:(CGRect)rect {
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    // 绘制图像
    UIImage *image = [UIImage imageNamed:@"exampleImage"];
    CGContextDrawImage(context, CGRectMake(20, 20, 100, 100), image.CGImage);
    
    // 添加滤镜效果
    CGContextSetBlendMode(context, kCGBlendModeMultiply);
    CGContextSetAlpha(context, 0.5);
    
    // 绘制文本
    NSString *text = @"Hello, World!";
    [text drawAtPoint:CGPointMake(20, 150) withAttributes:@{NSFontAttributeName: [UIFont systemFontOfSize:16], NSForegroundColorAttributeName: [UIColor redColor]}];
}

Swift示例:

// Swift示例：
// 在UIView的draw方法中结合Core Graphics绘制图像和文本

override func draw(_ rect: CGRect) {
    if let context = UIGraphicsGetCurrentContext() {
        // 绘制图像
        if let image = UIImage(named: "exampleImage") {
            context.draw(image.cgImage!, in: CGRect(x: 20, y: 20, width: 100, height: 100))
        }
        
        // 添加滤镜效果
        context.setBlendMode(.multiply)
        context.setAlpha(0.5)
        
        // 绘制文本
        let text = "Hello, World!"
        let attributes = [NSAttributedString.Key.font: UIFont.systemFont(ofSize: 16), NSAttributedString.Key.foregroundColor: UIColor.red]
        text.draw(at: CGPoint(x: 20, y: 150), withAttributes: attributes)
    }
}

3.5 绘制动画效果:

Objective-C示例:

// Objective-C示例：
#import <UIKit/UIKit.h>

@interface CustomView : UIView

@end

@implementation CustomView

- (void)drawRect:(CGRect)rect {
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    // 绘制路径
    CGContextSetStrokeColorWithColor(context, [UIColor.redColor CGColor]);
    CGContextSetLineWidth(context, 2.0);
    CGContextMoveToPoint(context, 50, 50);
    CGContextAddLineToPoint(context, 200, 200);
    CGContextStrokePath(context);
    
    // 创建路径动画
    CABasicAnimation *pathAnimation = [CABasicAnimation animationWithKeyPath:@"position"];
    pathAnimation.fromValue = [NSValue valueWithCGPoint:CGPointMake(50, 50)];
    pathAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(200, 200)];
    pathAnimation.duration = 2.0;
    
    // 添加动画
    [self.layer addAnimation:pathAnimation forKey:@"position"];
}

@end

Swift示例:

// Swift示例：
import UIKit

class CustomView: UIView {
    
    override func draw(_ rect: CGRect) {
        if let context = UIGraphicsGetCurrentContext() {
            // 绘制路径
            context.setStrokeColor(UIColor.red.cgColor)
            context.setLineWidth(2.0)
            context.move(to: CGPoint(x: 50, y: 50))
            context.addLine(to: CGPoint(x: 200, y: 200))
            context.strokePath()
            
            // 创建路径动画
            let pathAnimation = CABasicAnimation(keyPath: "position")
            pathAnimation.fromValue = CGPoint(x: 50, y: 50)
            pathAnimation.toValue = CGPoint(x: 200, y: 200)
            pathAnimation.duration = 2.0
            
            // 添加动画
            layer.add(pathAnimation, forKey: "position")
        }
    }
}

3.6 绘制图形上下文:

Objective-C示例:

// Objective-C示例：
- (UIImage *)drawCustomImage {
    UIGraphicsBeginImageContextWithOptions(CGSizeMake(200, 200), NO, 0.0);
    
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    // 绘制矩形
    CGContextSetFillColorWithColor(context, [UIColor blueColor].CGColor);
    CGContextFillRect(context, CGRectMake(50, 50, 100, 100));
    
    // 绘制文本
    NSString *text = @"Hello, Core Graphics!";
    [text drawAtPoint:CGPointMake(20, 20) withAttributes:@{NSFontAttributeName: [UIFont systemFontOfSize:16], NSForegroundColorAttributeName: [UIColor redColor]}];
    
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    
    return image;
}

Swift示例:

// Swift示例：
func drawCustomImage() -> UIImage? {
    UIGraphicsBeginImageContextWithOptions(CGSize(width: 200, height: 200), false, 0.0)
    
    if let context = UIGraphicsGetCurrentContext() {
        // 绘制矩形
        context.setFillColor(UIColor.blue.cgColor)
        context.fill(CGRect(x: 50, y: 50, width: 100, height: 100))
        
        // 绘制文本
        let text = "Hello, Core Graphics!"
        let attributes = [NSAttributedString.Key.font: UIFont.systemFont(ofSize: 16), NSAttributedString.Key.foregroundColor: UIColor.red]
        text.draw(at: CGPoint(x: 20, y: 20), withAttributes: attributes)
        
        if let image = UIGraphicsGetImageFromCurrentImageContext() {
            UIGraphicsEndImageContext()
            return image
        }
    }
    
    return nil
}

三、 Core Animation 框架

1. 主要特点和功能

Core Animation框架是iOS和macOS平台上用于实现动画效果和图层管理的核心框架。
它提供了一套强大的API，用于创建、组合和管理图层，实现各种动画效果和视觉效果。以下是Core Animation框架的一些主要特点和功能:

    1. 图层（CALayer）与图层管理:
    • CALayer是Core Animation框架的核心，用于管理视图的显示和动画效果。
      • CALayer提供了丰富的属性和方法，用于控制视图的外观、位置、大小等。
      • CALayer负责视图的渲染、布局、动画等操作，是视图的可视化表示。
    1. 动画（CAAnimation）:
    • CAAnimation是Core Animation框架中用于实现动画效果的基类。
    • 可以通过设置动画的属性和持续时间来实现各种动画效果。
    • CAAnimation包括:
      • 基础动画（CABasicAnimation）
      • 关键帧动画（CAKeyframeAnimation）
      • 过渡动画（CATransition）等类型。
    1. 图层组合:
    • 可以通过图层组合和图层树的方式来管理和组织视图的层级关系。
    • 可以创建复杂的图层结构，实现多层次的视图组合和效果叠加。
    1. 隐式动画:
    • Core Animation框架支持隐式动画，即通过改变图层的属性值来自动触发动画效果。
    • 可以通过设置图层的属性值来实现简单的动画效果，无需显式创建动画对象。
    1. 图层渲染:
    • Core Animation框架利用GPU硬件加速来实现图层的渲染和动画效果。
    • 可以实现流畅的动画效果和高性能的图层渲染。
    1. 交互效果:
    • Core Animation框架支持用户交互效果，如手势识别、点击事件等。
    • 可以通过手势识别和事件处理来实现交互式的动画效果。

2. 核心类介绍

Core Animation框架中的核心类主要包括以下几个：

    1. CALayer:
    • CALayer是Core Animation框架中的核心类，用于管理视图的显示和动画效果。
    • CALayer负责视图的渲染、布局、动画等操作，是视图的可视化表示。
    • CALayer提供了丰富的属性和方法，用于控制视图的外观、位置、大小等。
    1. CAAnimation:
    • CAAnimation是Core Animation框架中用于实现动画效果的基类。
    • CAAnimation包括基础动画（CABasicAnimation）、关键帧动画（CAKeyframeAnimation）、过渡动画（CATransition）等类型。
    • 开发者可以通过CAAnimation来创建各种动画效果，如平移、旋转、缩放等。
    1. CATransform3D:
    • CATransform3D是Core Animation框架中用于实现3D变换的类。
    • CATransform3D可以实现视图的平移、旋转、缩放等3D变换效果。
    • 开发者可以通过CATransform3D来创建复杂的3D变换效果，实现炫酷的视觉效果。
    1. CAEmitterLayer:
    • CAEmitterLayer是Core Animation框架中用于实现粒子效果的类。
    • CAEmitterLayer可以创建和管理粒子系统，实现雪花、火焰、烟雾等效果。
    • 开发者可以通过CAEmitterLayer来实现丰富的粒子效果，为应用程序增加动感和生动性。
    1. CAShapeLayer:
    • CAShapeLayer是Core Animation框架中用于绘制形状的类。
    • CAShapeLayer可以创建和管理各种形状，如矩形、圆角矩形、椭圆等。
    • 开发者可以通过CAShapeLayer来实现复杂的形状绘制和路径动画效果。
  • Core Animation 是常用的框架之一。它比 UIKit 和 AppKit 更底层。正如我们所知，UIView底下封装了一层CALayer树，Core Animation 层是真正的渲染层，我们之所以能在屏幕上看到内容，真正的渲染工作是在 Core Animation 层进行的。
  • Core Animation 是一套Objective-C API，实现了一个高性能的复合引擎，并提供一个简单易用的编程接口，给用户UI添加平滑运动和动态反馈能力。
  • Core Animation 是 UIKit 实现动画和变换的基础，也负责视图的复合功能。使用Core Animation可以实现定制动画和细粒度的动画控制，创建复杂的、支持动画和变换的layered 2D视图
  • OpenGL ES的内容也可以与Core Animation内容进行集成。
  • 为了使用Core Animation实现动画，可以修改 层的属性值 来触发一个action对象的执行，不同的action对象实现不同的动画。Core Animation 提供了一组基类及子类，提供对不同动画类型的支持：
    • CAAnimation 是一个抽象公共基类，CAAnimation采用CAMediaTiming 和CAAction协议为动画提供时间（如周期、速度、重复次数等）和action行为（启动、停止等）。
    • CAPropertyAnimation 是 CAAnimation的抽象子类，为动画提供一个由一个key路径规定的层属性的支持；
    • CABasicAnimation 是CAPropertyAnimation的具体子类，为一个层属性提供简单插入能力。
    • CAKeyframeAnimation 也是CAPropertyAnimation的具体子类，提供key帧动画支持。

四、 Core Graphics & Quartz 2D

1. 主要特点和功能

Core Graphics（Quartz 2D）是iOS和macOS平台上的2D绘图引擎,它是一套C-based API，用于实现图形绘制、图像处理和文本渲染等功能。
以下是Core Graphics & Quartz 2D的详细介绍:

    1. 绘图功能:
    • 绘图上下文:
      • Core Graphics使用绘图上下文（Graphics Context）来进行绘制操作，可以是基于位图的上下文、PDF上下文等。
    • Core Graphics提供了丰富的绘图功能，包括:
      • 绘制形状（直线、矩形、椭圆等）
      • 绘制路径（自定义路径、曲线路径等）
      • 绘制图像（位图图像、矢量图像等）
      • ...
    • 开发者可以在不同类型的上下文中进行绘制操作,创建自定义的绘图效果,实现各种绘图需求
    1. 图像处理:
    • Core Graphics支持图像的加载、绘制、裁剪、变换、合成、渲染 等操作 实现图像的特效和优化
    1. 文本渲染:
    • Core Graphics提供了文本渲染功能，可以渲染文本内容,可以控制文本样式、排版布局等实现文本的自定义渲染。
    1. 图形上下文:
    • Core Graphics使用图形上下文（Graphics Context）来管理绘图环境的状态和属性。
    • 通过设置图形上下文的属性来控制绘图效果，如颜色、线宽、填充模式等。
    1. 颜色和渲染:
    • Core Graphics支持颜色管理和渲染操作，可以设置填充颜色、描边颜色、渐变色等。
    1. 图形变换:
    • Core Graphics提供了图形变换的功能，可以实现平移、旋转、缩放等变换操作。
    1. 坐标系:
    • Core Graphics使用笛卡尔坐标系，原点在左下角，x轴向右延伸，y轴向上延伸。
    • 开发者可以通过坐标变换来实现坐标系的转换和调整，实现复杂的绘图效果和布局。
    1. 性能优化:
    • Core Graphics利用GPU硬件加速来实现图形渲染和处理，提高绘图效率和性能。
    • 开发者可以通过合理使用Core Graphics的API和功能来优化绘图性能，实现流畅的图形绘制和处理
    1. 其它
    • Core Graphics（使用Quartz 2D引擎）
      • 当开发者需要在运行时创建图像时，可以使用 Core Graphics 去绘制，运行时实时计算、绘制一系列图像帧来实现动画。
      • 与之相对的是运行前创建图像（例如从磁盘中或内存中已经创建好的UIImage图像）
    • Quartz 2D
      • Quartz 2D是Core Graphics中的2D 绘制呈现引擎。
      • Quartz 2D能够与所有的图形和动画技术（如Core Animation, OpenGL ES, 和 UIKit 等）一起使用。Quartz 2D采用paint模式进行绘制。

2. 核心类介绍

Core Graphics（Quartz 2D）框架中的核心类主要包括以下几个:

    1. CGContext:
    • CGContext是Core Graphics中的绘图上下文，用于执行绘图操作和渲染图形。
    • CGContext提供了绘制路径、图像、文本等的功能，是实现图形绘制的核心类。
    1. CGPath:
    • CGPath是Core Graphics中表示路径的类，用于创建和管理路径对象。
    • CGPath可以包含直线、曲线、矩形、椭圆等形状，用于定义绘制的轮廓和形状。
    • CGPath能够被填充和stroke
    1. CGImage:
    • CGImage是Core Graphics中表示图像的类，用于加载、创建和处理位图图像。
    • CGImage可以从文件、数据或其他来源创建，用于图像的绘制和处理。
    1. CGColor:
    • CGColor是Core Graphics中表示颜色的类，用于定义绘制和填充的颜色。
    • CGColor可以表示RGB、RGBA、灰度等颜色空间，用于设置绘制和填充的颜色值。
    • CGColor 和 CGColorSpace；用来进行颜色和颜色空间管理；
    1. CGGradient:
    • CGGradient是Core Graphics中表示渐变的类，用于创建和管理颜色渐变效果。
    • CGGradient可以定义线性渐变、径向渐变等效果，用于实现丰富的颜色渐变效果。
    • CGShading 和 CGGradient：用于绘制剃度；
    1. CTFont:
    • CTFont是Core Text框架中表示字体的类，用于处理文本的字体和排版。
    • CTFont可以设置字体的样式、大小、粗细等属性，用于文本的渲染和显示。
  • 其他常用类:
    • CGLayer：用来表示一个能够用于重复绘制和offscreen绘制的绘制层；
    • CGPattern：用来表示Pattern，用于重复绘制；
    • CGPDFContentStream、CGPDFScanner、CGPDFPage、CGPDFObject,CGPDFStream, CGPDFString 等用来进行pdf文件的创建、解析和显示

五、Core Image

Core Image是苹果提供的图像处理框架，主要用于实现图像处理、滤镜应用和图像分析等功能。以下是Core Image的核心要点:

1. 主要特点和功能

    1. 滤镜（Filter）:
    • Core Image提供了丰富的滤镜效果，如模糊、锐化、色彩调整、边缘检测等。
    • 开发者可以通过Core Image的滤镜功能对图像进行处理和增强。
    • iOS 8 之后 引入 CIFilter,Core Image从此支持自定义滤镜的创建和应用，实现个性化的图像处理效果。
    1. 图像处理链（Image Processing Pipeline）:
    • Core Image使用图像处理链来处理图像，包括输入图像、滤镜效果、和输出图像。
    • 开发者可以构建自定义的图像处理链，实现复杂的图像处理流程。
    1. 图像分析（Image Analysis）:
    • Core Image支持图像分析功能，如人脸检测、特征识别、颜色识别、物体识别等。
    • 开发者可以利用Core Image进行图像分析，提取图像中的信息和特征。
    1. Metal性能优化:
    • Core Image可以与Metal框架结合，利用GPU硬件加速来提高图像处理的性能。
    • 开发者可以通过Metal框架优化Core Image的性能，实现高效的图像处理和滤镜效果。
    1. 图像格式转换（Image Format Conversion）:
    • Core Image支持图像格式的转换和处理，如颜色空间转换、像素格式转换等。
    • 开发者可以使用Core Image进行图像格式的转换和处理，满足不同的图像处理需求。
    1. 实时预览（Real-time Preview）:
    • Core Image提供实时预览功能，可以在应用程序中实时显示滤镜效果的预览。
    • 开发者可以通过Core Image实现实时的滤镜预览，方便用户调整和查看效果。
    1. 其它
    • Core Image 与 Core Graphics 恰恰相反
      • Core Graphics 用于在运行时创建图像
      • 而 Core Image 是用来处理已经创建的图像的。
    • Core Image 是 iOS5 新加入到 iOS 平台的一个图像处理框架，提供了强大高效的图像处理功能， 用来对基于像素的图像进行操作与分析， 内置了很多强大的滤镜(Filter) (目前数量超过了180种)， 这些Filter 提供了各种各样的效果， 并且还可以通过 滤镜链 将各种效果的 Filter叠加 起来形成强大的自定义效果。
      • iOS8 之后更是支持自定义 CIFilter，可以定制满足业务需求的复杂效果。
    • Core Image 的优点在于十分高效。大部分情况下，它会在 GPU 中完成工作，但如果 GPU 忙，会使用 CPU 进行处理。如果设备支持 Metal，那么会使用 Metal 处理。这些操作会在底层完成，Apple 的工程师们已经帮助开发者们完成这些操作了。
      • 例如他可以根据需求选择 CPU 或者 GPU 来处理。
        // 创建基于 CPU 的 CIContext 对象 (默认是基于 GPU，CPU 需要额外设置参数)
  context = [CIContext contextWithOptions: [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:YES] forKey:kCIContextUseSoftwareRenderer]];
  // 创建基于 GPU 的 CIContext 对象
  context = [CIContext contextWithOptions: nil];
  // 创建基于 GPU 的 CIContext 对象
  EAGLContext *eaglctx = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
  context = [CIContext contextWithEAGLContext:eaglctx];
 ```

2. 核心类介绍

    1. CIImage:
    • CIImage是Core Image框架中表示图像数据的类，可以用来表示图像数据源
    • CIImage可以从各种来源创建，如UIImage、CGImage、NSData、图像文件或者像素数据等，用于输入到Core Image的滤镜中进行处理。
    1. CIFilter:
    • CIFilter是Core Image框架中的滤镜类，用于实现各种图像处理和滤镜效果。
    • CIFilter包含了各种内置的滤镜效果，也可以自定义滤镜来实现特定的图像处理需求。
    • 这个框架中对图片属性进行细节处理的类。它对所有的像素进行操作，用一些键-值设置来决定具体操作的程度。
    1. CIContext:
    • CIContext是Core Image框架中的上下文类，用于管理图像处理的环境和输出。
    • CIContext可以指定渲染目标（如屏幕、图像文件）、渲染选项（如颜色空间、缩放比例）等参数。
    1. CIFeature:
    • CIFeature是Core Image框架中的特征类，用于检测图像中的特征和对象。
    • CIFeature可以用于人脸检测、文本识别、条形码识别等应用场景。
    1. CIColor:
    • CIColor是Core Image框架中的颜色类，用于表示颜色信息。
    • CIColor可以用来创建颜色对象，设置滤镜效果中的颜色参数。
    1. CIVector:
    • CIVector是Core Image框架中的向量类，用于表示多维向量数据。
    • CIVector可以用来设置滤镜效果中的向量参数，如位置、大小等。

  • Core Image 的 API 主要就是三类：

    • CIContext 表示上下文，如 Core Graphics 以及 Core Data 中的上下文用于处理绘制渲染以及处理托管对象一样，Core Image 的上下文也是实现对图像处理的具体对象。可以从其中取得图片的信息。

六、Metal

1. 主要特点和功能

Metal是苹果公司推出的图形和计算框架，主要用于实现高性能的图形渲染和通用计算任务。以下是Metal框架的主要特点和功能:

    1. 低级别接口:
    • Metal提供了直接访问GPU的低级别接口，相比OpenGL和OpenCL等传统图形和计算框架更加高效。
    • 开发者可以更加精细地控制图形渲染和计算流程，实现更高性能的图形处理和计算任务。
    1. 高性能图形渲染:
    • Metal通过利用GPU的并行处理能力，实现高性能的图形渲染和效果处理。
    • Metal支持现代图形渲染技术，如着色器编程、纹理映射、光照效果、渲染三维场景等，可以实现复杂的图形渲染效果。
    1. 通用计算:
    • Metal不仅用于图形渲染，还可以用于通用计算任务，如机器学习、图像处理、物理模拟等。
    • Metal提供了计算着色器和计算管线，支持GPU加速的通用计算，提高计算任务的效率和速度。
    1. 着色器编程:
    • Metal使用着色器（Shader）来控制图形渲染和计算过程。
    • 开发者可以使用Metal Shading Language（MSL）编写着色器代码，实现定制化的图形效果和计算逻辑。
    1. 命令缓冲区:
    • Metal使用命令缓冲区（Command Buffer）来管理GPU命令的提交和执行。
    • 开发者可以创建和提交命令缓冲区，控制GPU的操作流程，实现高效的图形渲染和计算任务。
    1. 资源管理:
    • Metal提供了资源管理功能，用于管理GPU资源如缓冲区、纹理等。
    • 开发者可以创建和管理各种GPU资源，优化资源的使用和共享，提高图形渲染和计算的效率。
    1. 多线程并发:
    • Metal框架支持多线程并发，可以在多个线程上同时执行图形渲染和计算任务。
    • 开发者可以利用Metal的多线程特性实现并行处理，提高应用程序的性能和响应速度。
    1. 内存管理:
    • Metal提供了高效的内存管理机制，可以管理GPU资源和缓冲区的分配和释放。
    • Metal的内存管理功能可以帮助开发者优化内存使用，避免内存泄漏和性能下降。
    1. 跨平台支持:
    • Metal框架不仅支持iOS和macOS平台，还可以在tvOS上使用，实现跨平台的图形渲染和计算功能。
    • Metal提供了一致的API和功能，方便开发者在不同平台上实现统一的图形处理和计算任务

2. 核心类介绍

以下是Metal框架中一些核心类的介绍:

    1. MTLDevice:
    • MTLDevice是Metal框架中表示GPU设备的类，用于创建Metal对象和管理GPU资源。
    • 开发者可以通过MTLDevice创建其他Metal对象，如缓冲区、纹理等。
    1. MTLCommandQueue:
    • MTLCommandQueue是Metal框架中的命令队列类，用于提交和执行GPU命令。
    • 开发者可以将命令添加到MTLCommandQueue中，然后由GPU执行这些命令。
    1. MTLRenderPipelineState:
    • MTLRenderPipelineState是Metal框架中的渲染管线状态类，用于配置图形渲染管线。
    • 开发者可以通过MTLRenderPipelineState设置渲染管线的各个阶段，如顶点着色器、片元着色器等。
    1. MTLBuffer:
    • MTLBuffer是Metal框架中表示缓冲区的类，用于存储数据和传递给GPU。
    • 开发者可以创建MTLBuffer对象来传递顶点数据、纹理数据等到GPU进行处理。
    1. MTLTexture:
    • MTLTexture是Metal框架中表示纹理的类，用于存储和处理图像数据。
    • 开发者可以创建MTLTexture对象来加载纹理数据，用于图像处理和渲染。
    1. MTLComputePipelineState:
    • MTLComputePipelineState是Metal框架中的计算管线状态类，用于配置计算任务。
    • 开发者可以通过MTLComputePipelineState设置计算任务的各个阶段，如计算内核函数等。
    • Metal框架提供了直接访问GPU的能力，可以实现高性能的图形渲染和计算任务。通过这些核心类，开发者可以利用Metal框架实现复杂的图形渲染、计算任务和图形效果，为应用程序提供更加流畅和高性能的图形处理能力。

七、GPUImage

1. 主要特点和功能

GPUImage是一个基于OpenGL ES 2.0的开源图像处理框架，支持GPU加速，用于实现图像和视频处理的功能 以下是GPUImage框架的主要特点和功能:

    1. 滤镜（Filters）:
    • GPUImage提供了大量的滤镜效果，如色彩调整、模糊、锐化、边缘检测 等。
    • 开发者可以通过GPUImage提供的滤镜效果对图像和视频进行实时处理。
    • 定制滤镜（Custom Filters）:开发者可以通过编写自定义滤镜来扩展GPUImage的功能和效果，通过组合各种图像处理操作来创建个性化的滤镜效果，满足特定的处理需求。
    1. 处理链（Processing Chain）:
    • GPUImage支持链式处理图像和视频数据，可以将多个滤镜效果串联起来，实现复杂的处理流程，同时保持高效的处理速度
    • 每个处理步骤都可以添加不同的滤镜效果。
    • 开发者可以自定义处理链，实现复杂的图像处理流程。
    1. 实时相机（Camera）:
    • GPUImage提供了相机类，可以直接从摄像头捕获实时图像数据、视频流。
    • 开发者可以利用GPUImage的相机类实现实时滤镜效果和实时图像处理。
    1. 纹理（Textures）:
    • GPUImage使用OpenGL纹理来处理图像数据，提高处理效率和性能。
    • 开发者可以利用GPUImage的纹理处理功能实现高效的图像处理和渲染。
    1. 实时处理（Real-time Processing）:
    • GPUImage支持实时处理图像和视频流，可以在实时视频流中应用滤镜效果，实现实时的图像处理和增强。
    • 开发者可以利用GPUImage实现实时的图像处理效果，为应用程序增加更多的视觉吸引力
    1. 跨平台支持:
    • GPUImage不仅支持iOS平台，还支持Android平台和桌面平台，可以实现跨平台的图像处理应用开发。
    1. 易用性:
    • GPUImage提供了简洁易用的API和文档，使开发者能够快速上手并实现各种图像处理需求，降低开发成本和复杂度。
    1. GPU加速:
    • GPUImage利用GPU的并行计算能力来加速图像处理和滤镜效果的计算，提高处理速度和效率。

2. 核心类和协议介绍

核心类:

    1. GPUImageOutput:
    • GPUImageOutput是所有输出类的基类，用于处理图像数据的输出。
    • 其子类包括GPUImageFilter、GPUImagePicture等，用于实现不同的图像处理功能。
    1. GPUImageFilter:
    • GPUImageFilter是图像滤镜的基类，用于实现各种图像处理滤镜效果。
    • 开发者可以通过GPUImageFilter及其子类来应用各种滤镜效果，如模糊、锐化、色彩调整等。
    1. GPUImagePicture:
    • GPUImagePicture用于将静态图像加载到GPU中进行处理。
    • 可以通过GPUImagePicture加载UIImage或CGImage等静态图像数据，并传递给滤镜进行处理。
    1. GPUImageFramebuffer:
    • GPUImageFramebuffer用于在GPU中存储图像数据的帧缓冲区。
    • GPUImage处理图像数据时会使用帧缓冲区来存储中间结果，提高处理效率。
    1. GPUImageMovieWriter:
    • GPUImageMovieWriter是用于将视频数据写入文件的类。
    • GPUImageMovieWriter实现了GPUImageInput和GPUImageTextureOutput协议，可以接收图像数据并将处理后的视频数据写入文件。

协议:

    1. GPUImageInput:
    • GPUImageInput是输入类的协议，定义了接收图像数据的方法。
    • 所有需要接收图像数据的类都需要实现GPUImageInput协议，以便接收和处理图像数据。
    1. GPUImageTextureOutput:
    • GPUImageTextureOutput是输出纹理的协议，用于输出处理后的纹理数据。
    • 实现了GPUImageTextureOutput协议的类可以将处理后的纹理数据输出到其他地方，如屏幕、纹理等。

八、OpenGL ES

1. 主要特点和功能

OpenGL ES（OpenGL for Embedded Systems）是一种用于嵌入式系统的轻量级版本的OpenGL图形库，常用于移动设备和嵌入式系统中的图形渲染。以下是OpenGL ES的核心要点:

    1. 跨平台性:
    • OpenGL ES是跨平台的图形API，可以在多种移动设备和嵌入式系统上使用，如iOS、Android、嵌入式Linux等。
    1. 硬件加速:
    • OpenGL ES利用GPU硬件加速进行图形渲染，提供高性能的图形处理能力，适合移动设备和嵌入式系统的资源限制环境。
    1. 上下文管理:
    • OpenGL ES使用上下文（Context）来管理图形状态和资源，包括着色器程序、纹理、缓冲区等。
    • 开发者需要创建和管理OpenGL ES上下文，以便进行图形渲染和操作。
    1. 图形渲染:
    • OpenGL ES支持各种图形渲染功能，包括顶点处理、片元处理、纹理映射、着色器编程等，可以实现各种复杂的图形效果。
    • 着色器编程:
      • OpenGL ES使用着色器（Shader）来定义图形渲染的计算过程，包括顶点着色器和片元着色器。
      • 开发者可以编写自定义的着色器程序，用于实现各种图形效果和渲染算法。
    • 纹理映射:
      • OpenGL ES支持纹理映射（Texture Mapping），用于将纹理映射到几何图形表面,实现丰富的纹理效果和贴图功能。
      • 开发者可以加载纹理数据并将其映射到几何图形上，实现丰富的纹理效果。
    1. 缓冲区对象:
    • OpenGL ES使用缓冲区对象（Buffer Object），包括顶点缓冲区、索引缓冲区等来存储顶点数据、索引数据等。
    • 开发者可以创建和管理缓冲区对象，存储和传递图形数据，提供给GPU进行图形渲染
    1. 深度测试和混合:
    • OpenGL ES支持深度测试和混合功能，可以实现透明效果、深度排序等，提高图形渲染的真实感和逼真度。
    • 多重采样抗锯齿:
    • OpenGL ES支持多重采样抗锯齿（MSAA），可以减少图形渲染中的锯齿现象，提高图形质量。
    1. 光照和材质:
    • OpenGL ES支持光照和材质（Lighting and Material），用于模拟光照效果和物体表面的材质特性。
    • 开发者可以通过设置光照参数和材质属性来实现逼真的光照效果。
    1. 渲染管线:
    • OpenGL ES使用渲染管线（Rendering Pipeline）来处理图形渲染过程，包括顶点处理、几何处理、光栅化等阶段。
    • 开发者可以配置渲染管线的各个阶段，以实现定制的图形渲染效果。

2. 核心类介绍

    1. GLKView:
    • GLKView是OpenGL ES框架中用于显示OpenGL内容的视图类。
    • GLKView提供了一个方便的方式来在iOS应用中显示OpenGL渲染的内容。
    1. GLKViewController:
    • GLKViewController是OpenGL ES框架中的视图控制器类，用于管理OpenGL渲染和视图的交互。
    • GLKViewController可以处理渲染循环、用户交互等任务，简化OpenGL ES应用程序的开发。
    1. GLKBaseEffect:
    • GLKBaseEffect是OpenGL ES框架中的基本效果类，用于实现简单的渲染效果。
    • GLKBaseEffect提供了一些基本的渲染效果，如颜色、光照、纹理等。
    1. GLKTextureLoader:
    • GLKTextureLoader是OpenGL ES框架中的纹理加载器类，用于加载和管理纹理数据。
    • GLKTextureLoader可以从文件、内存等来源加载纹理数据，方便在OpenGL ES应用中使用纹理。
    1. GLKMath:
    • GLKMath是OpenGL ES框架中的数学库，用于处理矩阵、向量等数学运算。
    • GLKMath提供了一些常用的数学函数和数据结构，方便在OpenGL ES应用中进行数学计算。

九、ARKit和Metal框架

1. ARKit

1.1 主要特点和功能

ARKit是苹果公司提供的增强现实（AR）框架，用于在iOS设备上实现增强现实体验。以下是ARKit的主要特点和功能:

    1. 环境感知:
    • ARKit可以通过摄像头和传感器感知设备周围的环境，包括平面、垂直面、光照、特征点等。
    • ARKit提供了环境感知的功能，用于识别和追踪现实世界中的物体和场景。
    1. 跟踪技术:
    • ARKit支持视觉惯性里程计（Visual-Inertial Odometry）和基于特征点的跟踪技术。
    • ARKit可以实时追踪设备的位置和方向，实现精确的虚拟物体叠加在现实世界中。
    1. 虚拟内容叠加:
    • ARKit可以将虚拟内容叠加到设备摄像头捕捉的现实世界中，实现虚拟物体的显示和交互
    1. 场景理解:
    • ARKit可以理解设备所处的场景，包括平面检测、光照估计等。
    • ARKit可以检测水平和垂直平面，识别光照条件，为虚拟物体的渲染提供更真实的效果。
    1. 用户交互:
    • ARKit支持用户交互功能，可以通过手势、触摸、点击事件等方式与虚拟内容进行交互，如移动、旋转、缩放等操作。
    • 用户可以通过手势操作和触摸事件与增强现实场景进行交互，实现更加沉浸式的体验。
    1. 平面检测:
    • ARKit支持平面检测功能，可以识别水平面和垂直面，用于在现实世界中放置虚拟物体。
    1. 光照估计:
    • ARKit提供光照估计功能，可以根据环境光照条件调整虚拟内容的亮度和阴影，使其与现实世界更加融合。
    1. 持久性体验:
    • ARKit支持持久性体验，可以保存和恢复虚拟内容在现实世界中的位置。
    • 用户可以在不同时间点和场景中保持一致的增强现实体验，提升用户体验的连贯性。
    1. 面部追踪:
    • ARKit提供面部追踪功能，可以识别和追踪用户的面部表情，用于实现面部滤镜、AR表情等效果。
    1. 多设备协同:
    • ARKit支持多设备协同功能，可以实现多个设备之间的AR体验同步，如共享虚拟场景、多人协作等。

1.2 核心类介绍

ARKit框架中一些核心类的介绍:

    1. ARSession:
    • ARSession是ARKit框架中的会话类，用于管理AR体验的整个过程。
    • ARSession负责追踪设备的位置和方向，识别环境中的特征点，以及处理AR场景的渲染和更新。
    1. ARConfiguration:
    • ARConfiguration是ARKit框架中的配置类，用于配置AR会话的参数和设置。
    • ARConfiguration包括不同类型的配置，如ARWorldTrackingConfiguration、ARFaceTrackingConfiguration等，用于不同类型的AR体验。
    1. ARAnchor:
    • ARAnchor是ARKit框架中的锚点类，用于表示在AR场景中的位置和方向。
    • ARAnchor可以用于标记特定的位置或对象，以便在AR场景中进行定位和交互。
    1. ARSCNView:
    • ARSCNView是ARKit框架中的场景视图类，用于显示AR场景和渲染3D内容。
    • ARSCNView结合了SceneKit框架，可以方便地在AR场景中添加3D模型、动画等内容。
    1. ARPlaneAnchor:
    • ARPlaneAnchor是ARKit框架中的平面锚点类，用于表示检测到的水平平面。
    • ARPlaneAnchor可以用于在AR场景中识别和跟踪水平表面，如地面、桌面等。
    1. ARHitTestResult:
    • ARHitTestResult是ARKit框架中的命中测试结果类，用于检测AR场景中的交互命中结果。
    • ARHitTestResult可以用于检测用户在AR场景中的点击、触摸等交互操作。

通过这些核心类，开发者可以利用ARKit框架实现各种增强现实体验，包括追踪设备位置、识别环境特征、渲染3D内容等功能，为用户提供沉浸式的增强现实体验。

2. VR = ARKit+Metal 核心要点:

结合ARKit和Metal实现VR（Virtual Reality）体验的核心要点包括以下几个方面:

    1. ARKit中的空间追踪:
    • 使用ARKit进行空间追踪，可以实现设备在现实世界中的定位和追踪，为VR体验提供基础支持。
    • ARKit可以识别环境中的特征点、平面和物体，用于定位虚拟内容的位置和方向。
    1. Metal中的图形渲染:
    • 利用Metal进行高性能的图形渲染，可以实现流畅的虚拟现实场景呈现。
    • Metal提供了直接访问GPU的能力，可以实现复杂的图形渲染和计算任务，为VR体验提供高性能的图形处理支持。
    1. ARKit和Metal的集成:
    • 将ARKit和Metal结合起来，可以实现在AR场景中渲染虚拟内容，与现实世界进行交互。
    • 通过ARKit提供的空间追踪功能，将虚拟内容与现实世界对齐，再利用Metal进行图形渲染，实现沉浸式的VR体验。
    1. 交互和控制:
    • 在ARKit+Metal的VR体验中，可以通过手势识别、头部追踪等技术实现用户的交互和控制。
    • 用户可以通过手势、头部运动等方式与虚拟内容进行交互，增强VR体验的沉浸感和互动性。
    1. 性能优化:
    • 在实现ARKit+Metal的VR体验时，需要考虑性能优化，包括减少渲染延迟、优化图形质量、提高帧率等方面。
    • 通过合理的性能优化措施，可以确保VR体验的流畅性和稳定性。

3. 其它

本文主要针对官方自带的图形界面处理框架和比较流行的GPUImage框架进行简单介绍。暂不对AR、VR等相关技术展开更多讨论

十、Open CV、SpriteKit、Sence Kit

在iOS开发中,使用SpriteKit框架、Sence Kit框架 可以进行 2D、3D游戏开发。使用OpenCV可以进行计算机视觉处理开发。

1. Open CV

1.1 主要特点和功能

OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，提供了丰富的图像处理和计算机视觉算法。通过OpenCV提供的丰富功能和算法，开发者可以实现各种计算机视觉任务，包括图像处理、特征检测、目标检测、机器学习、特征提取、视频处理等，为图像处理和计算机视觉应用提供强大支持。 以下是OpenCV的核心要点:

    1. 图像处理:
    • OpenCV提供了各种图像处理功能，包括图像滤波、边缘检测、图像变换、颜色空间转换等。
    • 开发者可以利用OpenCV对图像进行处理和增强，实现各种图像处理需求。
    1. 特征检测和描述:
    • OpenCV包括多种特征检测和描述算法，如SIFT、SURF、ORB等。
    • 这些算法可以用于检测图像中的关键点、描述特征、匹配特征点等任务。
    1. 目标检测和跟踪:
    • OpenCV提供了目标检测和跟踪的功能，如Haar级联检测器、HOG检测器等。
    • 这些功能可以用于在图像或视频中检测和跟踪目标对象。
    1. 机器学习:
    • OpenCV集成了机器学习算法库，包括支持向量机（SVM）、K均值聚类、决策树等。
    • 开发者可以利用OpenCV进行机器学习任务，如分类、聚类、回归等。
    1. 摄像头标定和几何变换:
    • OpenCV提供了摄像头标定、透视变换、仿射变换等几何变换功能。
    • 这些功能可以用于校正图像畸变、实现图像配准、透视变换等任务。
    1. 图像分割和轮廓检测:
    • OpenCV包括图像分割和轮廓检测算法，如分水岭算法、边缘检测等。
    • 这些算法可以用于图像分割、对象检测、轮廓提取等应用。

1.2 核心类介绍

    1. Mat:
    • Mat是OpenCV中表示图像和矩阵数据的类，是最常用的数据结构之一。
    • Mat类可以存储图像数据、矩阵数据等，支持各种图像处理和计算操作。
    1. CascadeClassifier:
    • CascadeClassifier是OpenCV中的级联分类器类，用于对象检测和识别。
    • CascadeClassifier可以加载Haar级联分类器模型，用于人脸检测、目标检测等任务。
    1. VideoCapture:
    • VideoCapture是OpenCV中的视频捕获类，用于从摄像头或视频文件中捕获图像帧。
    • VideoCapture类可以实时捕获视频流，用于实时图像处理和分析。
    1. FeatureDetector:
    • FeatureDetector是OpenCV中的特征检测器类，用于检测图像中的特征点。
    • FeatureDetector可以检测关键点、角点、边缘等特征点，用于图像匹配和特征提取。
    1. DescriptorExtractor:
    • DescriptorExtractor是OpenCV中的描述子提取器类，用于提取特征点的描述子。
    • DescriptorExtractor可以计算特征点的描述子向量，用于特征匹配和识别。
    1. Imgproc:
    • Imgproc是OpenCV中的图像处理模块，提供了丰富的图像处理函数和算法。
    • Imgproc包括图像滤波、边缘检测、形态学操作、颜色空间转换等功能。
    1. HighGUI:
    • HighGUI是OpenCV中的图形用户界面模块，用于显示图像、视频和交互操作。
    • HighGUI提供了图像显示、窗口管理、鼠标事件处理等功能，方便图像处理的可视化展示。

1.3 其他

OpenCV 的 API 是 C++ 的。它由不同的模块组成，这些模块中包含范围极为广泛的各种方法，从底层的图像颜色空间转换到高层的机器学习工具。
这里提供一个入门PDF文档 下载入口。

  • 使用 C++ API 并不是绝大多数 iOS 开发者每天都做的事，你需要使用 Objective-C++ 文件来调用 OpenCV 的函数。
  • 也就是说，你不能在 Swift 或者 Objective-C 语言内调用 OpenCV 的函数。 这篇 OpenCV 的 iOS 教程告诉你只要把所有用到 OpenCV 的类的文件后缀名改为 .mm 就行了，包括视图控制器类也是如此。
  • 这么干或许能行得通，却不是什么好主意。正确的方式是给所有你要在 app 中使用到的 OpenCV 功能写一层 Objective-C++ 封装。
    • 这些 Objective-C++ 封装把 OpenCV 的 C++ API 转化为安全的 Objective-C API，以方便地在所有 Objective-C 类中使用。
    • 走封装的路子，你的工程中就可以只在这些封装中调用 C++ 代码，从而避免掉很多让人头痛的问题，比如直接改文件后缀名会因为在错误的文件中引用了一个 C++ 头文件而产生难以追踪的编译错误。

OpenCV 声明了命名空间 cv，因此 OpenCV 的类的前面会有个 cv:: 前缀，就像 cv::Mat、 cv::Algorithm 等等。

  • 你也可以在 .mm 文件中使用 using namespace cv 来避免在一堆类名前使用 cv::前缀。
  • 但是，在某些类名前你必须使用命名空间前缀，比如 cv::Rect 和 cv::Point，因为它们会跟定义在 MacTypes.h 中的 Rect 和 Point 相冲突。尽管这只是个人偏好问题，我还是偏向在任何地方都使用 cv::以保持一致性。

一般讲的OpenCV是基于CPU的，相关资料和支持也是最完善的。当然，也有基于GPU模块，但提供的接口非常坑爹:

  • 相当一部分不支持浮点类型（像histogram、integral这类常用的都不支持）

  • 又如，遇到阈值判断的地方，就必须传回cpu处理，因为gpu函数都是并行处理的，每改写完一个算法模块，就测试一下运行效率，有的时候是振奋人心，有的时候则是当头棒喝——比CPU还慢。详情可参阅 这里。

2. SpriteKit、Sence Kit

对于寻找游戏引擎的开发者来说，Metal 不是最佳选择。苹果官方的是更好的选择:

  • Scene Kit (3D)
  • Sprite Kit (2D)
  • 这些 API 提供了包括物理模拟在内的更高级别的游戏引擎。

另外还有功能更全面的 3D 引擎，例如 :

  • Epic 的 Unreal Engine 
  • 或 Unity
  • 二者都是跨平台的。使用这些引擎，你无需直接使用 Metal 的 API，就可以从 Metal 中获益。

2.1 2D渲染 -- SpriteKit

SpriteKit 让开发者可以开发高性能、省电节能的 2D 游戏。在 iOS 8 中，我们新添了多项增强功能，这将使 2D 游戏体验更加精彩。这些新技术有助于使游戏角色的动作更加自然，并让开发者可以更轻松地在游戏中加入力场、检测碰撞和生成新的灯光效果。

2.2 3D渲染 -- SceneKit

SceneKit 专为休闲 3D 游戏而设计，可让开发者渲染 3D 游戏场景。SceneKit 内置了物理引擎、粒子发生器和各种易用工具，可以轻松快捷地为 3D 物体编写动作。不仅如此，它还与 SpriteKit 完全集成，所以开发者可以直接在 3D 游戏中加入 SpriteKit 的素材。

3. 其它

本文主要针对官方自带的图形界面处理框架和比较流行的GPUImage框架进行简单介绍。暂不对游戏、计算机视觉等相关技术展开更多讨论

总结

本文主要针对官方自带的图形界面处理框架和比较流行视频图层处理框架进行简单介绍:

  • 系统自带框架
    • UIKit
    • Core Graphics
    • Core Image
    • Core Animation
    • Metal
  • 流行的第三方框架
    • GPUImage
    • OpenGL ES

后面会有几篇文章针对这几大块,进行更详细的介绍

本文尚未讨论

  • ARKit和Metal框架进行 XR开发（AR、VR）
  • Open CV 计算机视觉开发
  • SpriteKit、Sence Kit 游戏开发 若后面有时间,会进行简单的了解,给自己一个知识储备

系列文章

01-iOS 图层处理相关| 了解 移动端图片格式 和编解码【静态图片、动态图片】 (转)

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

原文链接： blog.ibireme.com

图片通常是移动端流量耗费最多的部分，并且占据着重要的视觉空间。合理的图片格式选用和优化可以为你节省带宽、提升视觉效果。在这篇文章里我会分析一下目前主流和新兴的几种图片格式的特点、性能分析、参数调优，以及相关开源库的选择。

几种图片格式的简介

首先谈一下大家耳熟能详的几种老牌的图片格式吧：

JPEG 是目前最常见的图片格式，它诞生于 1992 年，是一个很古老的格式。它只支持有损压缩，其压缩算法可以精确控制压缩比，以图像质量换得存储空间。由于它太过常见，以至于许多移动设备的 CPU 都支持针对它的硬编码与硬解码。

PNG 诞生在 1995 年，比 JPEG 晚几年。它本身的设计目的是替代 GIF 格式，所以它与 GIF 有更多相似的地方。PNG 只支持无损压缩，所以它的压缩比是有上限的。相对于 JPEG 和 GIF 来说，它最大的优势在于支持完整的透明通道。

GIF 诞生于 1987 年，随着初代互联网流行开来。它有很多缺点，比如通常情况下只支持 256 种颜色、透明通道只有 1 bit、文件压缩比不高。它唯一的优势就是支持多帧动画，凭借这个特性，它得以从 Windows 1.0 时代流行至今，而且仍然大受欢迎。

在上面这些图片格式诞生后，也有不少公司或团体尝试对他们进行改进，或者创造其他更加优秀的图片格式，比如 JPEG 小组的 JPEG 2000、微软的 JPEG-XR、Google 的 WebP、个人开发者发布的 BPG、FLIF 等。它们相对于老牌的那几个图片格式来说有了很大的进步，但出于各种各样的原因，只有少数几个格式能够流行开来。下面三种就是目前实力比较强的新兴格式了：

APNG 是 Mozilla 在 2008 年发布的一种图片格式，旨在替换掉画质低劣的 GIF 动画。它实际上只是相当于 PNG 格式的一个扩展，所以 Mozilla 一直想把它合并到 PNG 标准里面去。然而 PNG 开发组并没有接受 APNG 这个扩展，而是一直在推进它自己的 MNG 动图格式。MNG 格式过于复杂以至于并没有什么系统或浏览器支持，而 APNG 格式由于简单容易实现，目前已经渐渐流行开来。Mozilla 自己的 Firefox 首先支持了 APNG，随后苹果的 Safari 也开始有了支持， Chrome 目前也已经尝试开始支持 ，可以说未来前景很好。

WebP 是 Google 在 2010 年发布的图片格式，希望以更高的压缩比替代 JPEG。它用 VP8 视频帧内编码作为其算法基础，取得了不错的压缩效果。它支持有损和无损压缩、支持完整的透明通道、也支持多帧动画，并且没有版权问题，是一种非常理想的图片格式。借由 Google 在网络世界的影响力，WebP 在几年的时间内已经得到了广泛的应用。看看你手机里的 App：微博、微信、QQ、淘宝、网易新闻等等，每个 App 里都有 WebP 的身影。Facebook 则更进一步，用 WebP 来显示聊天界面的贴纸动画。

BPG 是著名程序员 Fabrice Bellard 在去年 (2014年) 发布的一款超高压缩比的图片格式。这个程序员大家可能有些面生，但说起他的作品 FFmpeg、QEMU 大家想必是都知道的。BPG 使用 HEVC (即 H.265) 帧内编码作为其算法基础，就这点而言，它毋庸置疑是当下最为先进的图片压缩格式。相对于 JP2、JPEG-XR、WebP 来说，同等体积下 BPG 能提供更高的图像质量。另外，得益于它本身基于视频编码算法的特性，它能以非常小的文件体积保存多帧动画。 Fabrice Bellard 聪明的地方在于，他知道自己一个人无法得到各大浏览器厂商的支持，所以他还特地开发了 Javascript 版的解码器，任何浏览器只要加载了这个 76KB 大小的 JS 文件，就可以直接显示 BPG 格式的图片了。目前阻碍它流行的原因就是 HEVC 的版权问题和它较长的编码解码时间。尽管这个图片格式才刚刚发布一年，但已经有不少厂子开始试用了，比如阿里和腾讯。

移动端图片类型的支持情况

目前主流的移动端对图片格式的支持情况如何呢？我们分别来看一下 Android 和 iOS 目前的图片编解码架构吧：

mobileimagearch

Android 的图片编码解码是由 Skia 图形库负责的，Skia 通过挂接第三方开源库实现了常见的图片格式的编解码支持。

  • 目前来说，Android 原生支持的格式只有 JPEG、PNG、GIF、BMP 和 WebP (Android 4.0 加入)，在上层能直接调用的编码方式也只有 JPEG、PNG、WebP 这三种。
  • 目前来说 Android 还不支持直接的动图编解码。

iOS 底层是用 ImageIO.framework 实现的图片编解码。

  • 目前 iOS 原生支持的格式有：JPEG、JPEG2000、PNG、GIF、BMP、ICO、TIFF、PICT
  • 自 iOS 8.0 起，ImageIO 又加入了 APNG、SVG、RAW 格式的支持。在上层，开发者可以直接调用 ImageIO 对上面这些图片格式进行编码和解码。对于动图来说，开发者可以解码动画 GIF 和 APNG、可以编码动画 GIF。

两个平台在导入第三方编解码库时，都多少对他们进行了一些修改，比如 Android 对 libjpeg 等进行的调整以更好的控制内存，iOS 对 libpng 进行了修改以支持 APNG，并增加了多线程编解码的特性。除此之外，iOS 专门针对 JPEG 的编解码开发了 AppleJPEG.framework，实现了性能更高的硬编码和硬解码，只有当硬编码解码失败时，libjpeg 才会被用到。

静态图片的编码与解码

由于我目前主要是做 iOS 开发，所以下面的性能评测都是基于 iPhone 的，主要测试代码可以在这里看到。测试素材很少，只有两个：

dribbble512pngcrushlena512weibo

第一张是Dribbble 的 Logo，包含 Alpha 通道，用于测试简单的、图形类的图像。
第二张经典的 Lena 图，用于测试照片类的、具有丰富细节的图像。
每个图像都有 64x64、128x128、256x256、512x512 四种分辨率。

JPEG

目前比较知名的 JPEG 库有以下三个：

libjpeg：开发时间最早，使用最广泛的 JPEG 库。由于 JPEG 标准过于复杂和模糊，并没有其他人去实现，所以这个库是 JPEG 的事实标准。

libjpeg-turbo：一个致力于提升编解码速度的 JPEG 库。它基于 libjpeg 进行了改造，用 SIMD 指令集 (MMX、SSE2、NEON) 重写了部分代码，官网称相对于 libjpeg 有 2 到 4 倍的性能提升。

MozJPEG： 一个致力于提升压缩比的 JPEG 库。它是 Mozilla 在 2014 年发布的基于 libjpeg-turbo 进行改造的库，相对于 libjpeg 有 5% ~ 15%的压缩比提升，但相应的其编码速度也慢了很多。

除了上面这三个库，苹果自己也开发了一个 AppleJPEG，但并没有开源。其调用了芯片提供的 DSP 硬编码和硬解码的功能。虽然它不如上面这三个库功能完善，但其性能非常高。在我的测试中，其编解码速度通常是 libjpeg-turbo 的 1~2 倍。可惜的是，目前开发者并不能直接访问这个库。

下面是 ImageIO (AppleJPEG/libpng) 在 iPhone 6 上的编解码性能：

jpegbenchdribbble jpegbenchlena

可以看到，JPEG 编码中 quality 越小，图片体积就越小，质量越也差，编码时间也越短。解码时间并没有很大的差距，可能是其大部分时间消耗在了函数调用、硬件调用上。苹果在自己的相册 Demo 中提供的 quality 的默认值是 0.9，在这个值附近，图像质量和体积、编码解码时间之间都能取得不错的平衡。

PNG

相对于 JPEG 来说，PNG 标准更为清晰和简单，因此有很多公司或个人都有自己的 PNG 编码解码实现。但目前使用最广的还是 PNG 官方发布的 libpng 库。iOS 和 Android 底层都是调用这个库实现的 PNG 编解码。

下面是 PNG 在 iPhone 6 上的编解码性能：

jpegpngbench

可以看到，在编解码图形类型（颜色少、细节少）的图片时，PNG 和 JPEG 差距并不大；但是对于照片类型（颜色和细节丰富）的图片来说，PNG 在文件体积、编解码速度上都差 JPEG 不少了。

和 JPEG 不同，PNG 是无损压缩，其并不能提供压缩比的选项，其压缩比是有上限的。目前网上有很多针对 PNG 进行优化的工具和服务，旨在提升 PNG 的压缩比。下面是常见的几个 PNG 压缩工具的性能对比：

pngtoolsbench

pngcrush 是 Xcode 自带的 PNG 压缩工具，相对于设计师用 Photoshop 生成的图片来说，它能取得不错的压缩效果。ImageOptim 则更进一步，对每张图用多种缩算法进行比对，选择压缩比更高的结果，进一步缩小了文件体积。TinyPNG.com 相对于其他工具来说，压缩比高得不像话。它启用了类似 GIF 那样的颜色索引表对 PNG 进行压缩，所以会导致颜色丰富的图片丢失掉一部分细节。如果使用 TinyPNG 的话，最好在压缩完成后让设计师看一下颜色效果是否可以接受。

WebP

WebP 标准是 Google 定制的，迄今为止也只有 Google 发布的 libwebp 实现了该的编解码 。 所以这个库也是该格式的事实标准。

WebP 编码主要有几个参数：

lossless: YES:有损编码 NO:无损编码。WebP 主要优势在于有损编码，其无损编码的性能和压缩比表现一般。

quality: [0~100] 图像质量，0表示最差质量，文件体积最小，细节损失严重，100表示最高图像质量，文件体积较大。该参数只针对有损压缩有明显效果。Google 官方的建议是 75，腾讯在对 WebP 评测时给出的建议也是 75。在这个值附近，WebP 能在压缩比、图像质量上取得较好的平衡。

method: [0~6] 压缩比，0表示快速压缩，耗时短，压缩质量一般，6表示极限压缩，耗时长，压缩质量好。该参数也只针对有损压缩有明显效果。调节该参数最高能带来 20% ～ 40% 的更高压缩比，但相应的编码时间会增加 5～20 倍。Google 推荐的值是 4。

对于

  • 编码无损图片来说，quality=0, method=0~3 是相对来说比较合适的参数，能够节省编码时间，同时也有不错的压缩比。
  • 无损编码图片，quality=75, method=2~4 是比较合适的参数，能在编码时间、图片质量、文件体积之间有着不错的平衡。

WebP 解码有三个参数：

use_threads: 是否启用 pthread 多线程解码。该参数只对宽度大于 512 的有损图片起作用。开启后内部会用多线程解码，CPU 占用会更高，解码时间平均能缩短 10%～20%。

bypass_filtering: 是否禁用滤波。该参数只对有损图片起作用，开启后大约能缩短 5%～10% 的解码时间，但会造成一些颜色过渡平滑的区域产生色带（banding）。

no_fancy_upsampling: 是否禁用上采样。该参数只对有损图片起作用。在我的测试中，开启该参数后，解码时间反而会增加 5～25%，同时会造成一些图像细节的丢失，线条边缘会增加杂色，显得不自然。

通常情况下，这三个参数都设为 NO 即可，如果要追求更高的解码速度，则可以尝试开启 use_threads 和 bypass_filtering 这两个参数。而 no_fancy_upsampling 在任何情况下都没必要开启。

由于 WebP 测试数据较多，这里只贴一下 512x512 大小的一部分测试结果，感兴趣的可以看文章结尾处的 Excel 附件。

webpbench

对于简单的图形类型的图像（比如 App 内的各种 UI 素材），WebP 无损压缩的文件体积和解码速度已经比 PNG 还要理想了，如果你想要对 App 安装包体积进行优化，WebP 已经是个不错的选择了。

对于复杂的图像（比如照片）来说，WebP 无损编码表现并不好，但有损编码表现却非常棒。相近质量的图片解码速度 WebP 相距 JPEG 已经差不了太多了，而文件压缩比却能提升不少。

BPG

BPG 是目前已知最优秀的有损压缩格式了，它能在相同质量下比 JPEG 减少 50% 的体积。下面是经典的 Lena 图的对比，你也可以在这里看到大量其他图片的 BPG、JPEG、JPEG2000、JPEG-XR、WebP 压缩效果的在线对比，效果非常明显。

bpgdemo

BPG 目前只有作者发布的 libbpg 可用。但作者基于 libbpg 编译出了一个 Javascript 解码器，很大的扩展了可用范围。bpg 可以以无损和有损压缩两种方式进行编码，有损压缩时可以用 quality 参数控制压缩比，可选范围为 0～51，数值越大压缩比越高。通常来说，25 附近是一个不错的选择，BPG 官方工具默认值是 28。

libbpg 目前并没有针对 ARM NEON 做优化，所以其在移动端的性能表现一般。下面是 iPhone 6 上的性能测试：

bpgbench

由于 bpg 编码时间太长，我并没有将数据放到表格里。可以看到相同质量下，BPG 的解码速度还是差 JPEG 太多，大约慢了 3～5 倍。目前来说，BPG 适用于那些对流量非常敏感，但对解码时间不敏感的地方。从网上的新闻来看，手机淘宝和手机QQ都已经有所尝试，但不清楚他们是否对 BPG 解码进行了优化。

小结

  • JPEG 压缩速度快, 压缩质量较弱于 PNG(结合 压缩质量 和压缩速度 综合考虑，用JPEG格式比较多)
  • PNG
    • 在编解码图形类型（颜色少、细节少）的图片时，PNG 和 JPEG 差距并不大；
    • 但是对于照片类型（颜色和细节丰富）的图片来说，PNG 在文件体积、编解码速度上都差 JPEG 不少了。
    • 和 JPEG 不同，PNG 是无损压缩，其并不能提供压缩比的选项，其压缩比是有上限的。
  • WebP 主要优势在于有损编码，无损压缩性能表现一般
  • BPG 是目前已知最优秀的有损压缩格式了，它能在相同质量下比 JPEG 减少 50% 的体积。相同质量下,BPG速度比JPEG压缩速度慢很多

动态图片的编码与解码

动图在网络上非常受欢迎，它近似视频，但通常实现简单、文件体积小，应用范围非常广泛。动图的始祖是 GIF，它自 Windows 1.0 时代就在互联网上流行开来，直到今天仍然难以被其他格式取代。尽管它非常古老，但其所用的原理和今天几种新兴格式几乎一样。

下面是一张 GIF 格式的 QQ 大表情：

benchgifdemo

这张表情由 6 幅静态图构成，每幅图片有一定的存活时间，连贯播放就形成了动画：

benchgifdemo1

这几张图中，大部分内容是相近的，为了压缩文件体积，通常动图格式都支持一些特殊的方式对相似图片进行裁剪，只保留前后帧不同的部分：

benchgifdemo2

在解码动图时，解码器通常采用所谓"画布模式"进行渲染。想象一下：播放的区域是一张画布，第一帧播放前先把画布清空，然后完整的绘制上第一帧图；播放第二帧时，不再清空画布，而是只把和第一帧不同的区域覆盖到画布上，就像油画的创作那样。

像这样的第一帧就被称为关键帧（即 I 帧，帧内编码帧），而后续的那些通过补偿计算得到的帧被称为预测编码帧（P帧）。一个压缩的比较好的动图内，通常只有少量的关键帧，而其余都是预测编码帧；一个较差的压缩工具制作的动图内，则基本都是关键帧。不同的动图压缩工具通常能得到不同的结果。

除此之外，动图格式通常有更为详细的参数控制每一帧的绘制过程，下面是 GIF/APNG/WebP 通用的几个参数：

Disposal Method (清除方式) 
   Do Not Dispose：把当前帧增量绘制到画布上，不清空画布。
   Restore to Background：绘制当前帧之前，先把画布清空为默认背景色。
   Restore to Previous：绘制下一帧前，把先把画布恢复为当前帧的前一帧

Blend Mode (混合模式) 
   Blend None: 绘制时，全部通道（包含Alpha通道）都会覆盖到画布，相当于绘制前先清空画布的指定区域。
   Blend over：绘制时，Alpha 通道会被合成到画布，即通常情况下两张图片重叠的效果。

上面这些技术，就是常见动图格式的基础了，下面分别介绍一下不同动图格式的特点。

GIF

GIF 缺陷非常明显：它通常只支持 256 色索引颜色，这导致它只能通过抖动、差值等方式模拟较多丰富的颜色；它的 Alpha 通道只有 1 bit，这意味着一个像素只能是完全透明或者完全不透明。

gifapngdemo

上面这是腾讯博客里的一张演示图，可以看到 GIF 由于 Alpha 通道的问题，产生了严重的"毛边"现象。目前通常的解决方案是在图片的边缘加一圈白边，以减轻这种视觉效果：

gifwrongdemo

可以仔细观察一下 QQ、微信等 App 里面的动画表情，几乎每个表情都被一圈白边所环绕，不得不说是一种很无奈的解决方案。

GIF 的制作工具有很多，但效果好、压缩比高的工具非常少。对于已经制作好的 GIF 来说，用 imagemagick 处理一下可以把文件体积压缩不少。如果需要将视频转为 GIF，Cinemagraph Pro 是个不错的傻瓜化工具。这里有一篇文章介绍如何用 ffmpeg 压缩 GIF，虽然参数调节有点麻烦，但效果非常理想。

下面是没有经过优化的 GIF 和经过 ffmpeg 优化编码的 GIF，可以看到差距非常大。

[ bbb-nodither

APNG

APNG 目前并没有被 PNG 官方所接受，所以 libpng 并不能直接解码 APNG。但由于 APNG 只是基于 PNG 的一个简单扩展，所以在已经支持 PNG 的平台上，可以很轻松的用少量代码实现 APNG 的编解码。Chromium 为了支持 APNG 播放，只增加了不到 600 行代码 ，我自己也用大概 500 行 C 代码实现了一个简单的 APNG 编解码工具。另外，在支持 canvas 的浏览器上，可以用 apng-canvas 直接显示 APNG 动画。APNG 压缩最好的工具目前是 apngasm，大部分图形化工具比如腾讯的 iSparta 都是基于这个工具开发的。

就目前而言， APNG 是 GIF 最好的替代了：实现简单，可用范围广，压缩比不错，显示效果好。

WebP

WebP 在 2010 年 发布时并没有支持动图。2012 年 libwebp v0.2 的时候，Google 才开始尝试支持动画，但其实现有很多问题，性能也非常差，以至于 Chrome 团队一直都没有接受。直到 2013 年，libwebp v0.4 时，动画格式才稳定下来才被 Chrome 所接受。

WebP 动图实际上是把多个单帧 WebP 数据简单打包到一个文件内，而并不是由单帧 WebP 扩展而来，以至于动图格式并不能向上兼容静态图。如果要支持动图，首先在编译 libwebp 时需要加上 demux 模块，解码 WebP 时需要先用 WebPDemuxer 尝试拆包，之后再把拆出来的单帧用 WebPDecode 解码。为了方便编译，我写了个脚本用于打包 iOS 的静态库，加入了 mux 和 demux 模块。

Google 提供了两个简单的命令行工具用于制作动图：gif2webp 能把 GIF 转换为 WebP， webpmux 能把多个 WebP 图片打包为动态图，并且有着很多参数可以调节。这两个工具对相近帧的压缩并不太理想，以至于有的情况下压缩比还不如 APNG，但除此以外也没有其他什么更好的工具可以用了。

BPG

BPG 本身是基于 HEVC (H.265) 视频编码的，其最开始设计时就考虑到了动图的实现。由于它充分利用了 HEVC 的高压缩比和视频编码的特性，其动图压缩比远超其他格式。这里和这里有几张 BPG 动图示例，可以看到相同质量下 BPG 动图只有 APNG/WebP/GIF 几十分之一的大小。

我在这里写了个简单的利用 libbpg 解码动图的方法，如有需要可以参考下。

动图性能对比

我把下面这张 GIF 分别转为 WebP、APNG、BPG 动图，并在 iPhone 6 上对其所有帧进行解码。

gifermilio

评测结果如下：

animbench

APNG 在文件体积上比 GIF 略有优势，解码时间相差不多。WebP 在体积和解码时间上都具有较大的优势。BPG 在体积上优势最大，但解码时间也最长。这么看来，APNG 和 WebP 都是不错的选择，而 BPG 还有待性能优化。

最后做一个小广告：如果你是 iOS 平台的开发者，可以试试我开发的 YYWebImage，它支持 APNG、WebP、GIF 动图的异步加载与播放、编码与解码，支持渐进式图像加载，可以替代 SDWebImage、PINRemoteImage、FLAnimatedImage 等开源库。

小结

  • GIF 缺陷非常明显：它通常只支持 256 色索引颜色，这导致它只能通过抖动、差值等方式模拟较多丰富的颜色；它的 Alpha 通道只有 1 bit，这意味着一个像素只能是完全透明或者完全不透明。
  • APNG 是 GIF 最好的替代了：实现简单，可用范围广，压缩比不错，显示效果好

评测数据

上面提到的所有评测数据表格：image_benchmark.xlsx 推荐用 Excel 打开查看。

iOS-Swift语法静态分析配置|统一编码规范【Fastlane+SwiftLint】

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

Swiftlint 介绍

安装Fastlane

使用 Fastlane 上传 App 到蒲公英

www.pgyer.com/doc/view/fa…

Fastlane 是一款为 iOS 和 Android 开发者提供的自动化构建工具，它可以帮助开发者将 App 打包、签名、测试、发布、信息整理、提交 App Store 等工作完整的连接起来，实现完全自动化的工作流，如果使用得当，可以显著的提高开发者的开发效率。

为了让使用 Fastlane 的用户，可以将 Fastlane 的自动化工作流与蒲公英结合起来，我们为大家提供了 Fastlane 的蒲公英插件。该插件使用起来非常简单，安装该插件后，由 Fastlane 打包生成的 App 可以自动上传到蒲公英。

前置条件

  1. 开发者使用的是 mac 或 linux 系统
  2. 已经安装好 ruby、rubygems、bundler
  3. 已经安装了 Fastlane。如果没有安装，请参考：官方安装指南
  4. 开发者了解基本的 App 开发流程、终端的使用方法
  5. 本文使用环境为：macOS 10.13, Xcode 9.2, Fastlane 2.78.0, fastlane-plugin-pgyer 0.2.1

配置SwiftLint的lane

设置工程的Fastlane配置

给项目添加SwiftLint

  • 安装Fastlane
  • 配置Fastlane的Fastfile
    • 添加一个lane
    # This file contains the fastlane.tools configuration
# You can find the documentation at https://docs.fastlane.tools
#
# For a list of all available actions, check out
#
#     https://docs.fastlane.tools/actions
#
# For a list of all available plugins, check out
#
#     https://docs.fastlane.tools/plugins/available-plugins
#

# Uncomment the line if you want fastlane to automatically update itself
# update_fastlane

default_platform(:ios)

platform :ios do
    desc "Description of what the lane does"

    lane :lint do
    swiftlint(
      mode: 'lint',    # 运行 SwiftLint 的模式
      config_file: 'swiftlint.yml',    # SwiftLint 配置文件的路径（可选）
      ignore_exit_status: true    # 忽略 SwiftLint 的退出状态，以允许 Fastlane 继续执行
    )
    end
end
    • 在工程主目录添加swiftlint文件:(swiftlint.yml) image.png
      • 可以在github上搜索、参考：一些大公司的Swiftlint规则设置,进行编写
      • 也可以直接使用以下的配置:
      # Enabled Rules

opt_in_rules:

  - anyobject_protocol

  - array_init

  - attributes

  - block_based_kvo

  - capture_variable

  - class_delegate_protocol

  - closing_brace

  - closure_body_length

  - closure_end_indentation

  - closure_parameter_position

  - closure_spacing

  - collection_alignment

  - colon

  - comma

  - compiler_protocol_init

  - contains_over_filter_count

  - contains_over_filter_is_empty

  - contains_over_first_not_nil

  - contains_over_range_nil_comparison

  - control_statement

  - custom_rules

  - deployment_target

  - discarded_notification_center_observer

  - discouraged_direct_init

  - discouraged_none_name

  - discouraged_object_literal

  - duplicate_enum_cases

  - duplicate_imports

  - duplicated_key_in_dictionary_literal

  - dynamic_inline

  - empty_collection_literal

  - empty_count

  - empty_enum_arguments

  - empty_parameters

  - empty_parentheses_with_trailing_closure

  - empty_string

  - empty_xctest_method

  - enum_case_associated_values_count

  - expiring_todo

  - explicit_init

  - fallthrough

  - fatal_error_message

  - file_header

  - file_length

  - first_where

  - flatmap_over_map_reduce

  - for_where

  - force_cast

  - force_try

  - function_body_length

  - function_parameter_count

  - generic_type_name

  - ibinspectable_in_extension

  - identical_operands

  - identifier_name

  - implicit_getter

  - implicit_return

  - implicitly_unwrapped_optional

  - indentation_width

  - inert_defer

  - is_disjoint

  - joined_default_parameter

  - large_tuple

  - last_where

  - leading_whitespace

  - legacy_cggeometry_functions

  - legacy_constant

  - legacy_constructor

  - legacy_hashing

  - legacy_multiple

  - legacy_nsgeometry_functions

  - legacy_random

  - let_var_whitespace

  - line_length

  - literal_expression_end_indentation

  - mark

  - missing_docs

  - modifier_order

  - multiline_arguments

  - multiline_function_chains

  - multiline_literal_brackets

  - multiline_parameters

  - multiple_closures_with_trailing_closure

  - no_extension_access_modifier

  - no_fallthrough_only

  - no_space_in_method_call

  - notification_center_detachment

  - nslocalizedstring_require_bundle

  - nsobject_prefer_isequal

  - number_separator

  - operator_usage_whitespace

  - operator_whitespace

  - optional_enum_case_matching

  - orphaned_doc_comment

  - overridden_super_call

  - override_in_extension

  - prefer_self_type_over_type_of_self

  - prefer_zero_over_explicit_init

  - private_over_fileprivate

  - private_subject

  - private_unit_test

  - prohibited_interface_builder

  - prohibited_super_call

  - protocol_property_accessors_order

  - reduce_boolean

  - reduce_into

  - redundant_discardable_let

  - redundant_nil_coalescing

  - redundant_objc_attribute

  - redundant_optional_initialization

  - redundant_set_access_control

  - redundant_string_enum_value

  - redundant_void_return

  - return_arrow_whitespace

  - shorthand_operator

  - sorted_first_last

  - sorted_imports

  - statement_position

  - superfluous_disable_command

  - switch_case_alignment

  - syntactic_sugar

  - toggle_bool

  - trailing_comma

  - trailing_newline

  - trailing_semicolon

  - trailing_whitespace

  - type_body_length

  - type_contents_order

  - type_name

  - unavailable_function

  - unneeded_break_in_switch

  - unneeded_parentheses_in_closure_argument

  - unowned_variable_capture

  - untyped_error_in_catch

  - unused_capture_list

  - unused_closure_parameter

  - unused_control_flow_label

  - unused_declaration

  - unused_enumerated

  - unused_import

  - unused_optional_binding

  - unused_setter_value

  - valid_ibinspectable

  - vertical_parameter_alignment

  - vertical_parameter_alignment_on_call

  - vertical_whitespace

  - vertical_whitespace_between_cases

  - vertical_whitespace_closing_braces

  - void_return

  - weak_delegate

  - xctfail_message

  - yoda_condition




# Disabled Rules

disabled_rules:

  - balanced_xctest_lifecycle # don't require balanced test setup and teardown

  - conditional_returns_on_newline # principles encourage one-line if and guard statements where applicable

  - cyclomatic_complexity # we have many complex switches that have over 100 cases

  - discouraged_assert # we don't currently prefer assertionFailure() and preconditionFailure() over assert(false)

  - discouraged_optional_boolean # disabled b/c nil, false, and true are all valid cases

  - discouraged_optional_collection # disabled b/c it looks at function signatures as well

  - explicit_acl # implicit internal ACL is a nice convenience

  - explicit_enum_raw_value # implicit raw values is a nice convenience

  - explicit_self # principles encourage you to drop self when it is not needed

  - explicit_top_level_acl # implicit internal ACL is a nice convenience

  - explicit_type_interface # implied Int and String types is a nice convenience

  - extension_access_modifier # extension declarations should not have an ACL modifier

  - file_types_order # type ordering cannot be consistent in all cases

  - force_unwrapping # disabled b/c of guards and ternary use cases

  - function_default_parameter_at_end # closures are often after parameters with default values

  - lower_acl_than_parent # only makes sense to enable if `no_extension_access_modifier` is disabled

  - multiline_arguments_brackets # doesn't match coding standards for collection parameters without external name

  - multiline_parameters_brackets # doesn't match coding standards for multi-line methods and functions

  - nesting # principles encourage namespacing through nested types

  - nimble_operator # not using nimble

  - no_grouping_extension # principles encourage grouping type functionality into extensions

  - nslocalizedstring_key # don't use genstrings due to loctool

  - object_literal # don't use color or image literals

  - opening_brace # doesn't support our multi-line function formatting

  - pattern_matching_keywords # principles encourage consistency and ease of reading

  - prefixed_toplevel_constant # not a good Swift pattern to prefix with `k`

  - private_action # don't use storyboards or nibs

  - private_outlet # don't use storyboards or nibs

  - quick_discouraged_call # not using quick

  - quick_discouraged_focused_test # not using quick

  - quick_discouraged_pending_test # not using quick

  - raw_value_for_camel_cased_codable_enum # don't restrict codable usage for webservice payloads

  - required_deinit # useful for debugging, but too extreme to require for all codebases

  - required_enum_case # this rule makes no sense...10 gold stars to anyone that can explain it

  - single_test_class # principles encourage multiple testcase classes in same file

  - static_operator # structs and classes should use static functions in extensions, not protocols

  - strict_fileprivate # still valid use cases for fileprivate

  - strong_iboutlet # don't use storyboards or nibs

  - switch_case_on_newline # principles encourage single line cases where applicable

  - trailing_closure # enforces trailing closure use even when function is called on multiple lines

  - vertical_whitespace_opening_braces # doesn't match coding standards for MARKs in structs and classes

  - xct_specific_matcher # valid cases where equal is more readable with optional bool tests




# Excluded Directories

excluded:

  - Pods

  - Submodules




reporter: "xcode"




# Configurable Rules

closure_body_length:

  warning: 100

  error: 140




deployment_target:

  iOS_deployment_target: 10.0

  macOS_deployment_target: 10.12

  tvOS_deployment_target: 10.0

  watchOS_deployment_target: 3.0




expiring_todo:

  approaching_expiry_threshold: 15

  date_format: "MM/dd/yyyy"

  date_delimiters:

    opening: "["

    closing: "]"

  date_separator: "/"




file_header:

  required_pattern: |

    \/\/

    \/\/  .*?\.swift

    \/\/  [\w ]*

    \/\/

    \/\/  Created by ([a-zA-Z-]+ ){2,4}on \d{1,2}\/\d{1,2}\/\d{2}\.

    \/\/  Copyright © \d{4} Nike\. All rights reserved\.

    \/\/




file_length:

  warning: 1000

  error: 1200

  ignore_comment_only_lines: true




function_body_length:

  warning: 200

  error: 240




function_parameter_count:

  warning: 8

  error: 12




generic_type_name:

  min_length: 1

  max_length: 40




identifier_name:

  min_length: 1

  max_length: 50

  excluded: ["id"]

  allowed_symbols: ["_"] # for gray_8D and _somePrivateVariable

  validates_start_with_lowercase: true




large_tuple:

  warning: 5

  error: 7




line_length:

  warning: 140

  error: 160

  ignores_urls: false

  ignores_function_declarations: false

  ignores_comments: false




modifier_order:

  preferred_modifier_order: [

    "acl",

    "setterACL",

    "override"

]




number_separator:

  minimum_length: 6

  minimum_fraction_length: 100 # to simply disable it




type_body_length:

  warning: 600

  error: 800




type_contents_order:

  order: [

    ["case"],

    ["type_alias", "associated_type", "subtype", "type_property", "instance_property"],

    ["ib_outlet"],

    ["ib_inspectable"],

    ["initializer", "deinitializer"],

    ["type_method"],

    ["subscript"],

    ["view_life_cycle_method"],

    ["ib_action"],

    ["other_method"]

  ]




type_name:

  min_length: 3

  max_length: 50

  allowed_symbols: ["_"]




# Custom Rules

custom_rules:

  fixme:

    include: ".*swift"

    name: "FIXME"

    regex: "((?i)(FIXME))"

    match_kinds:

      - comment

    message: "Unfinished Code"

    severity: warning




  hanging_else_keyword:

    included: ".*\\.swift"

    name: "There should not be a newline character after the `else` keyword."

    regex: "\\else\\s*\\n+"

    severity: warning




  todo_format:

    include: ".*swift"

    name: "TODO"

    regex: "((?i)(TODO: ))(?![A-Z]+-)"

    match_kinds:

      - comment

    message: "TODO should include Jira ticket e.g. '// TODO: TEAM-xxxx:'"

    severity: warning




  no_newlines_after_indent_changes_before_comments:

    included: ".*\\.swift"

    name: "No Newlines After Indent Changes Before Comments"

    regex: "\\{[\\w ]*?\\n[ ]*?\\n[ ]*\\/{2,3}[ ](?!MARK)"

    severity: warning




  blank_line_after_closing_brace_or_parenthesis:

    included: ".*\\.swift"

    name: "A Closing Brace/Parenthesis On Its Own Line Must Have a Newline Between It and Any Code"

    regex: "\\n[ ]*?[\\}\\)]\\n[ ]*?(?!set|case|else)[\\w]"

    severity: warning




  triple_quotation_marks_on_declaring_line:

    included: ".*\\.swift"

    name: "First Triple Quotation Marks Must Be On Declaring Line"

    regex: "=\\n[ ]*\"\"\""

    severity: warning




  no_extra_newline_after_open_brace:

    included: ".*\\.swift"

    name: "No Extra Newline After An Open Brace"

    regex: "\\{\\n *\\n(?! *\\/\\/ MARK)"

    severity: warning




  uppercase_id_suffix:

    included: ".*\\.swift"

    name: "ID suffix should always be all uppercase"

    regex: "[\\w]*Id\\b"

    match_kinds:

      - argument

      - comment

      - identifier

      - parameter

    severity: warning




  uppercase_url_suffix:

    included: ".*\\.swift"

    name: "URL suffix should always be all uppercase"

    regex: "[\\w]*Url\\b"

    match_kinds:

      - argument

      - comment

      - identifier

      - parameter

    severity: warning




  uppercase_json_suffix:

    included: ".*\\.swift"

    name: "JSON suffix should always be all uppercase"

    regex: "[\\w]*Json\\b"

    match_kinds:

      - argument

      - comment

      - identifier

      - parameter

    severity: warning




  test_case_suffix:

    included: ".*\\.swift"

    name: "Test case suffix should always be 'TestCase'"

    regex: "[\\w]*Tests:"

    match_kinds:

      - identifier

    severity: warning
    • 配置工程,添加启动脚本 image.png 
    # Type a script or drag a script file from your workspace to insert its path.

if which swiftlint >/dev/null; then

  swiftlint

else

  echo "warning: SwiftLint not installed, download from https://github.com/realm/SwiftLint"

fi
    • 在终端切换到该工程目录下,执行Fastlane命令:bundle exec fastlane lint

SwiftUI 快速上手推荐

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

前言

最近在回顾Flutter技术时,与老同事聊起SwiftUI,我们了解到SwiftUI和Flutter UI技术都是声明式语法,因此近两天写了一些Demo进行简单尝试

一、SwiftUI快速上手

为了快速上手,我找了一些对SwiftUI有所研究的博主,跟着对方的博客笔记敲击了十来个Demo: image.png 在多次尝试之后,我发现,通过SwiftUI写UI,的确会一定程度上减少代码量。

二、博文推荐

SwiftUI快速上手推荐:

三、SwiftUI与UIKit的异同:

  • 1. 声明式 vs 命令式：SwiftUI 是声明式的，你只需要描述界面应该是什么样子，而 SwiftUI 会处理实际的渲染过程。而 UIKit 是命令式的，你需要告诉 UIKit 如何一步步地创建和更新界面。
  • 2. 跨平台：SwiftUI 可以在所有 Apple 平台（包括 iOS、macOS、watchOS 和 tvOS）上使用，而 UIKit 只能用于 iOS 和 tvOS。
  • 3. 组件：SwiftUI 提供了一些 UIKit 中没有的组件，如 Grid 和 Form。同时，SwiftUI 的组件在所有 Apple 平台上都有一致的外观和行为。
  • 4. 数据流：SwiftUI 引入了一些新的数据流概念，如 @State、@Binding、@ObservedObject 和 @EnvironmentObject，它们使得数据状态管理更加直观和一致。而在 UIKit 中，你通常需要手动管理数据状态和更新界面。
  • 5. 兼容性：SwiftUI 需要 iOS 13 或更高版本，而 UIKit 可以在更早的 iOS 版本上使用。
  • 6. 成熟度：UIKit 已经存在了很长时间，有大量的文档、教程和社区支持。而 SwiftUI 是在 2019 年才推出的，虽然它正在快速发展，但还没有 UIKit 那么成熟。

总的来说，SwiftUI 提供了一种更现代、更简洁的方式来构建界面，但如果你需要支持旧的 iOS 版本，或者需要使用 UIKit 提供的一些高级功能，那么 UIKit 仍然是一个很好的选择。

四、SwiftUI布局

写了几个Demo后,我们可以了解到,其实要用SwiftUI斜截面,掌握SwiftUI的布局方法很重要

在 SwiftUI 中，布局主要由容器视图（如 HStack、VStack 和 ZStack）和修饰符（如 padding、frame 和 offset）来控制。

以下是一些常用的容器视图：

- HStack：在水平方向上排列其子视图。
- VStack：在垂直方向上排列其子视图。
- ZStack：在深度方向上堆叠其子视图。

以下是一些常用的修饰符: - padding：给视图添加内边距。
- frame：设置视图的尺寸和对齐方式。
- offset：移动视图的位置。

在HStack、VStack、ZStack中还可以用spacing来约束,容器内部子视图的间距

iOS13 Scene Delegate详解(转)

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

scenedelegate_logo.jpg

iOS13 项目中的SceneDelegate类有什么作用？自从Xcode11发布以来，当你使用新XCode创建一个新的iOS项目时，SceneDelegate会被默认创建，它到底有什么用呢。

在本文中，我们将深入探讨iOS 13和Xcode 11的一些变化。我们将重点关注SceneDelegate和AppDelegate，以及它们如何影响SwiftUI、Storyboard和基于XIB的UI项目。

通过阅读本文你将了解到:

  • SceneDelegate和AppDelegate的新变化
  • 他们是如何合作引导你的app启动的
  • 在纯手写App中使用SceneDelegate
  • 在Storyboards 和 SwiftUI项目中使用SceneDelegate

让我们开始吧。

本篇文章基于 Xcode 11 和 iOS 13.

AppDelegate

你可能对AppDelegate已经熟悉，他是iOS app的入口，application(_:didFinishLaunchingWithOptions:)是你的app启动后系统调用的第一个函数。

AppDelegate类实现了UIKit库中的UIApplicationDelegate 协议。而到了iOS13 AppDelegate的角色将会发生变化，后面我们会详细讨论。

下面是你在iOS12中一般会在AppDelegate中做的事情：

  • 创建app的第一个view controller也就是 rootViewController
  • 配置并启动一些像日志记录和云服务之类的组件
  • 注册推送通知处理程序，并响应发送到app的推送通知
  • 响应应用程序生命周期事件，例如进入后台，恢复应用程序或退出应用程序（终止）

iOS12及以前，使用Storyboards的app，AppDelegate很简单。 像这样：

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
{
    return true
}

一个使用XIB的简单应用看起来像这样：

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
{   
    let timeline = TimelineViewController()
    let navigation = UINavigationController(rootViewController: timeline)

    let frame = UIScreen.main.bounds
    window = UIWindow(frame: frame)

    window!.rootViewController = navigation
    window!.makeKeyAndVisible()

    return true
}

在上面的代码中，我们创建一个ViewController,并将其放在navigation controller中。然后将其分配给UIWindow对象的rootViewController属性。 这个window对象是AppDelegate的属性，它是我们的应用的一个窗口。

应用程序的window是一个重要的概念。 本质上，窗口就是应用程序，大多数iOS应用程序只有一个窗口。 它包含您应用的用户界面（UI），将事件调度到视图，并提供了一个主要背景层来显示您的应用内容。 从某种意义上说，“ Windows”的概念就是微软定义的窗口，而在iOS上，这个概念没有什么不同。 （谢谢，Xerox！）

好了，下面让我们继续SceneDelegate。

如果“窗口”的概念仍然不了解，请查看iPhone上的应用程序切换器。 双击Home键或从iPhone底部向上滑动，然后您会看到当前正在运行的应用程序的窗口。 这就是应用程序切换器。

The Scene Delegate

在iOS 13（及以后版本）上，SceneDelegate将负责AppDelegate的某些功能。 最重要的是，window（窗口）的概念已被scene（场景）的概念所代替。 一个应用程序可以具有不止一个场景，而一个场景现在可以作为您应用程序的用户界面和内容的载体（背景）。

尤其是一个具有多场景的App的概念很有趣，因为它使您可以在iOS和iPadOS上构建多窗口应用程序。 例如，文档编辑器App中的每个文本文档都可以有自己的场景。 用户还可以创建场景的副本，同时运行一个应用程序的多个实例（类似多开）。

在Xcode 11中有三个地方可以明显地看到SceneDelegate的身影：

  1. 现在，一个新的iOS项目会自动创建一个SceneDelegate类，其中包括我们熟悉的生命周期事件，例如active，resign和disconnect。
  2. AppDelegate类中多了两个与“scene sessions”相关的新方法：application(_:configurationForConnecting:options:) 和 application(_:didDiscardSceneSessions:)
  3. Info.plist文件中提供了”Application Scene Manifest“配置项，用于配置App的场景，包括它们的场景配置名，delegate类名和storyboard

让我们一次开看一看。

1. Scene Delegate Class

首先，SceneDelegate类：

scene-delegate-1.jpg

SceneDelegate的最重要的函数是：scene(_:willConnectTo:options:)。 在某种程度上，它与iOS 12上的 application(_:didFinishLaunchingWithOptions:) 函数的作用最相似。当将场景添加到app中时scene(_:willConnectTo:options:)函数会被调用的，因此这里是配置场景的最理想地方。 在上面的代码中，我们手动地设置了视图控制器堆栈，稍后会进行详细介绍。

这里需要特别注意的是，“SceneDelegate”采用了协议模式，并且这个delegate通常会响应任何场景。 您使用一个Delegate来配置App中的所有场景。

SceneDelegate 还具有下面这些函数:

  • sceneDidDisconnect(_:) 当场景与app断开连接是调用（注意，以后它可能被重新连接）
  • sceneDidBecomeActive(_:) 当用户开始与场景进行交互（例如从应用切换器中选择场景）时，会调用
  • sceneWillResignActive(_:) 当用户停止与场景交互（例如通过切换器切换到另一个场景）时调用
  • sceneWillEnterForeground(_:) 当场景变成活动窗口时调用，即从后台状态变成开始或恢复状态
  • sceneDidEnterBackground(_:) 当场景进入后台时调用，即该应用已最小化但仍存活在后台中

看到函数的对称性了吗？ Active/inactive, background/foreground, 和 “disconnect”. 。 这些是任何应用程序的典型生命周期事件。

2.App Delegate中的Scene Sessions

在iOS13中AppDelegate中有两个管理Senen Session的代理函数。在您的应用创建scene（场景）后，“scene session”对象将跟踪与该场景相关的所有信息。

这两个函数是:

  • application(_:configurationForConnecting:options:), 会返回一个创建场景时需要的UISceneConfiguration对象
  • application(_:didDiscardSceneSessions:), 当用户通过“应用切换器”关闭一个或多个场景时会被调用

目前，SceneSession被用于指定场景，例如“外部显示” 或“ CarPlay” 。 它还可用于还原场景的状态，如果您想使用【状态还原】，SceneSession将非常有用。 状态还原允许您在应用启动之间保留并重新创建UI。 您还可以将用户信息存储到场景会话中，它是一个可以放入任何内容的字典。

application(_:didDiscardSceneSessions:)很简单。 当用户通过“应用程序切换器”关闭一个或多个场景时，即会调用该方法。 您可以在该函数中销毁场景所使用的资源，因为不会再需要它们。

了解application(_:didDiscardSceneSessions:)与sceneDidDisconnect（_ :)的区别很重要，后者仅在场景断开连接时调用，不会被丢弃，它可能会重新连接。而application（_：didDiscardSceneSessions：）发生在使用【应用程序切换器】退出场景时。

3. Info.plist 中的Application Scene Manifest

您的应用支持的每个场景都需要在“Application Scene Manifest”（应用场景清单）中声明。 简而言之，清单列出了您的应用支持的每个场景。 大多数应用程序只有一个场景，但是您可以创建更多场景，例如用于响应推送通知或特定操作的特定场景。

Application Scene Manifest清单是Info.plist文件的一项，都知道该文件包含App的配置信息。 Info.plist包含诸如App的名称，版本，支持的设备方向以及现在支持的不同场景等配置。

请务必注意，您声明的是会话的“类型”，而不是会话实例。 您的应用程序可以支持一个场景，然后创建该场景的副本，来实现【多窗口】应用程序。

下面看一下的 Info.plist中清单的一些配置:

scene-manifest-2.jpg

在红框内，您会看到Application Scene Manifest 这一条。 在它下面一条是Enable Multiple Windows，需要将其设置为“ YES”以支持多个窗口。 再往下Application Session Role的值是一个数组，用于在应用程序中声明场景。 你也可以在数组中添加一条【外部屏幕】的场景声明。

最重要的信息保存在Application Session Role数组中。 从中我们可以看到以下内容：

  • Configuration的名称，必须是唯一的
  • 场景的代理类名，通常为SceneDelegate。
  • 场景用于创建初始UI的storyboard名称

Storyboard名称这一项可能使您想起Main Interface设置，该设置可以在Xcode 12项目的Project Properties配置中找到。 现在，在iOS应用中，你可以在此处设置或更改主Storyboard名称。

AppDelegate中的SceneDelegate、UISceneSession和Application Scene Manifest是如何一起创建多窗口应用的呢？

  • 首先，我们看SceneDelegate类。 它管理场景的生命周期，处理各种响应，诸如 sceneDidBecomeActive(_:) and sceneDidEnterBackground(_:)之类的事件。
  • 然后，我们再看看AppDelegate类中的新函数。 它管理场景会话（scene sessions），提供场景的配置数据，并响应用户丢弃场景的事件。
  • 最后，我们看了一下Application Scene Manifest。 它列出了您的应用程序支持的场景，并将它们连接到delegate类并初始化storyboard。

Awesome! Now that we’ve got a playing field, let’s find out how scenes affects building UIs in Xcode 11.

太棒了！ 现在让我们了解scenes（场景）是如何影响Xcode 11中的用户界面的吧。

在SwiftUI中使用Scene Delegate

不久将来，SwiftUI将是创建iOS 13项目最简单的方法。 简言之，SwiftUI应用程序主要依靠SceneDelegate来设置应用程序的初始UI。

首先，SwiftUI项目中“Application Scene Manifest ”将长这样：

scene-manifest-3.jpg

特别注意，配置中没有设置“Storyboard Name”这一项。 请记住，如果要支持多个窗口，则需要将Enable Multiple Windows设置为YES。

我们将跳过“ AppDelegate”，因为它相当标准。在SwiftUI项目中，只会返回“true”。

接下来是SceneDelegate类。 正如我们之前讨论的，SceneDelegate负责设置您应用中的场景，以及设置首个页面。

像下面一样:

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {

        let contentView = ContentView()

        if let windowScene = scene as? UIWindowScene {
            let window = UIWindow(windowScene: windowScene)
            window.rootViewController = UIHostingController(rootView: contentView)
            self.window = window
            window.makeKeyAndVisible()
        }
    }
}

上面的代码中发生了什么？

  • 首先，必须明确的是 在将新场景添加到应用中后 会调用scene(_：willConnectTo：options：)代理函数。 它提供了一个scene对象（和一个session）。 这个“UIWindowScene”对象是由应用创建的，您无需进行其他操作。
  • 其次，window属性会在这里用到。 App仍然使用“ UIWindow”对象，但现在它们已成为scene（场景）的一部分。 在if let代码块中，您可以清楚地看到如何使用scene来初始化UIWindow对象的。
  • 然后是设置window的rootViewController，将window实例分配给了场景的window属性，并且设置窗口makeKeyAndVisible为true，即将该窗口置于App的前面。
  • 接着为SwiftUI项目创建了ContentView实例，并通过使用UIHostingController将其添加为根视图控制器。 该控制器用于将基于SwiftUI的视图显示在屏幕上。
  • 最后但并非不重要的一点，值得注意的是，UIScene的实例化对象scene实际上是UIWindowScene类型的对象。 这就是as?对可选类型转换的原因。 （到目前为止，已创建的场景通常为“ UIWindowScene”类型，但我猜想将来还会看到更多类型的场景。）

所有这些看起来似乎很复杂，但是从高层次的概述来看，这很简单：

  • 当scene（_：willConnectTo：options：）被调用时，SceneDelegate会在正确的时间配置场景。
  • AppDelegate和Manifest的默认配置，他们没有涉及storyboard的任何东西。
  • scene（_：willConnectTo：options :)函数内，创建一个SwiftUI视图，将其放置在托管控制器中，然后将控制器分配给window属性的根视图控制器，并将该窗口放置在应用程序UI的前面 。

太棒了！ 让我们继续。

您可以通过选择File（文件）→New（新建）→Project（项目）来建立一个基本的Xcode 11项目。 然后，选择Single View App, 在User Interface处选择SwiftUI来创建一个SwiftUI项目

在Storyboards项目中使用SceneDelegate

Storyboards和XIB是为iOS应用程序构建UI的有效方法。 在iOS 13上也是如此。 在将来，我们将看到更多的SwiftUI应用，但目前，Storyboards更常见。

有趣的是，即使有了SceneDelegate，通过Storyboards创建iOS项目你也不需要做任何额外的事情 只需选择File → New → Project。 然后，选择Single View App。 最后，为 User Interface 处选择 Storyboard ，就完成了。

设置方法如下：

  • 如我们前面提到过的，您可以在Info.plist中的“ Application Scene Manifest”中找到Main storyboard的设置地方。
  • 默认情况下，AppDelegate将使用默认的UISceneConfiguration。
  • SceneDelegate会设置一个“UIWindow”对象，并使用“Main.storyboard”来创建初始UI。

纯代码编写UI

许多开发人员喜欢手写UI，而随着SwiftUI的兴起，使用SwiftUI手写代码将会越来越常见。 如果您不使用storyboards，而使用XIB创建应用程序UI，该怎么办？ 让我们看看SceneDelegate如何修改。

首先，AppDelegate和Application Scene Manifest中保持默认值。 我们不使用storyboard，所以需要在SceneDelegate类的scene(_:willConnectTo:options:)函数中设置初始视图控制器。

像下面这样：

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions)
    {
        if let windowScene = scene as? UIWindowScene {

            let window = UIWindow(windowScene: windowScene)
            let timeline = TimelineViewController()

            let navigation = UINavigationController(rootViewController: timeline)
            window.rootViewController = navigation

            self.window = window
            window.makeKeyAndVisible()
        }
    }
}

上面代码很简单我们就不详细介绍了。

很简单，对吧？ 使用SceneDelegate的核心是将一些代码从AppDelegate移至到SceneDelegate中，并正确配置 Application Scene Manifest 。

想要为现有的iOS项目添加scene(场景)支持？ 可以查看Apple官方文档https://developer.apple.com/documentation/uikit/app_and_environment/scenes/specifying_the_scenes_your_app_supports。

作者：Reinder de Vries

翻译：乐Coding

作者：乐Coding
链接：https://juejin.cn/post/6844903993496305671

Swift 加密方案与密钥生成方法|加密方案:【SwiftyRSA与CryptoSwift】、密钥生成方法：【RSA 密钥、 ECC 密钥、国密密钥】

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

一、SwiftyRSA与CryptoSwift

推荐两个加密方案开源框架:

具体的使用方式,参照链接中的README.md

二、密钥

根据开发的业务需求，查看生成密钥的方法。密钥包括 RSA 密钥、ECC 密钥、国密密钥。

前置条件

已通过 OpenSSL 官网 下载并安装 OpenSSL 工具（1.1.1 或以上版本）

生成 RSA 密钥

  1. 打开 OpenSSL 工具，使用以下命令行生成 RSA 私钥。您可以选择生成 1024 或 2048 位的私钥。

    openssl genpkey -algorithm RSA -out private_key.pem -pkeyopt rsa_keygen_bits:2048

  2. 根据 RSA 私钥生成 RSA 公钥。

    openssl rsa -pubout -in private_key.pem -out public_key.pem

生成 ECC 密钥

  1. 打开 OpenSSL 工具，使用以下命令行生成 ECC 的密钥对。您必须选择 secp256k1 椭圆曲线算法。

    openssl ecparam -name secp256k1 -genkey -noout -out secp256k1-key.pem

  2. 根据 secp256k1-key.pem 密钥对生成 ECC 公钥。

    openssl ec -in secp256k1-key.pem -pubout -out ecpubkey.pem

生成国密密钥

  1. 打开 OpenSSL 工具，使用以下命令行生成国密 SM2 私钥 sm2-key.pem。

    openssl ecparam -name SM2 -genkey -noout -out sm2-key.pem

  2. 根据 sm2-key.pem 密钥对生成国密 SM2 公钥 sm2pubkey.pem。

    openssl ec -in sm2-key.pem -pubout -out sm2pubkey.pem

01-H5与Native交互-JS与Native互调|WebViewJavaScriptBridge 基本使用(转)

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

一、iOS中的WebView

在 iOS 开发 Hybrid App 的时候，有两个 WebView 可以选择:

  • UIWebView
  • WKWebView

这两个 WebView 控件，可以完全只借助 iOS 自带的框架进行 OC & JS 交互。

  1. UIWebView 使用 JavaScriptCore.
  2. WKWebView 使用 WKUserContentController.

二、WebView 与 原生的交互原理

UIWebView 原生的交互原理
通过一个 JSContext 获取 UIWebView 的 JS 执行上下文。
然后通过这个上下文，进行 OC & JS 的双端交互。

_jsContext = [webView valueForKeyPath:@"documentView.webView.mainFrame.javaScriptContext"];
_jsContext.exceptionHandler = ^(JSContext *context, JSValue *exception) {
    NSLog(@"%@",@"获取 WebView JS 执行环境失败了!");
};

WKWebView 原生交互原理

通过 userContentController 把需要观察的 JS 执行函数注册起来。
然后通过一个协议方法，将所有注册过的 JS 函数执行的参数传递到此协议方法中。

注册 需要 观察的 JS 执行函数

[webView.configuration.userContentController addScriptMessageHandler:self name:@"jsFunc"];

在 JS 中调用这个函数并传递参数数据

window.webkit.messageHandlers.jsFunc.postMessage({name : "李四",age : 22});

OC 中遵守 WKScriptMessageHandler 协议。

- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message

此协议方法里的 WKScriptMessage 有 name & body 两个属性。 name 可以用来判断是哪个 JSFunc 调用了。body 则是 JSFunc 传递到 OC 的参数。

三、WebViewJavaScriptBridge

WebViewJavaScriptBridge 用于 WKWebView & UIWebView 中 OC 和 JS 交互。
它的基本原理是：

把 OC 的方法注册到桥梁中，让 JS 去调用。
把 JS 的方法注册在桥梁中，让 OC 去调用。

WebViewJavascriptBridge 基本原理

image.png

注册自己，调用它人。

四、WebViewJavaScriptBridge 使用的基本步骤

  1. 首先在项目中导入 WebViewJavaScriptBridge 框架。
pod ‘WebViewJavascriptBridge’
  1. 导入头文件 #import <WebViewJavascriptBridge.h> 。
  2. 建立 WebViewJavaScriptBridge 和 WebView 之间的关系。
_jsBridge = [WebViewJavascriptBridge bridgeForWebView:_webView];
  1. 在HTML 文件中，复制粘贴这两段 JS 函数。

function setupWebViewJavascriptBridge(callback) {
        if (window.WebViewJavascriptBridge) { return callback(WebViewJavascriptBridge); }
        if (window.WVJBCallbacks) { return window.WVJBCallbacks.push(callback); }
        window.WVJBCallbacks = [callback]; // 创建一个 WVJBCallbacks 全局属性数组，并将 callback 插入到数组中。
        var WVJBIframe = document.createElement('iframe'); // 创建一个 iframe 元素
        WVJBIframe.style.display = 'none'; // 不显示
        WVJBIframe.src = 'wvjbscheme://__BRIDGE_LOADED__'; // 设置 iframe 的 src 属性
        document.documentElement.appendChild(WVJBIframe); // 把 iframe 添加到当前文导航上。
        setTimeout(function() { document.documentElement.removeChild(WVJBIframe) }, 0)
    }
    
    // 这里用于注册 Native 将要调用的 JS 方法。
    setupWebViewJavascriptBridge(function(bridge){
       
    });

到此为止，基本的准备工作就做完了。现在需要往桥梁中注入 OC 方法 和 JS 函数了。

往桥梁中注入 OC 方法 和 JS 函数

往桥梁中注入 OC 方法。

[_jsBridge registerHandler:@"scanClick" handler:^(id data, WVJBResponseCallback responseCallback) {
    NSLog(@"dataFrom JS : %@",data[@"data"]);
    responseCallback(@"扫描结果 : www.baidu.com");
}];

这段代码的意思：

  1. scanClick 是 OC block 的一个别名。
  2. block 本身，是 JS 通过某种方式调用到 scanClick 的时候，执行的代码块。
  3. data ，由于 OC 这端由 JS 调用，所以 data 是 JS 端传递过来的数据。
  4. responseCallback OC 端的 block 执行完毕之后，往 JS 端传递的数据。

往桥梁中注入 JS 函数.

OC 方法，在 OC 中注入。JS 的方法所以必然就需要在 JS 中注入的。（好像是废话)
在 JS 的方法如何注入到桥梁呢？

之前，在准备工作的时候，有两段 JS 代码。
需要在第二段 JS 代码中，注入 JS 的函数。


// 这里主要是注册 OC 将要调用的 JS 方法。
    setupWebViewJavascriptBridge(function(bridge){
        // 声明 OC 需要调用的 JS 方法。
        bridge.registerHanlder('testJavaScriptFunction',function(data,responseCallback){
            // data 是 OC 传递过来的数据.
            // responseCallback 是 JS 调用完毕之后传递给 OC 的数据
            alert("JS 被 OC 调用了.");
            responseCallback({data: "js 的数据",from : "JS"});
        })
    });

这段代码的意思：

  1. testJavaScriptFunction 是注入到桥梁中 JS 函数的别名。以供 OC 端调用。
  2. 回调函数的 data。 既然 JS 函数由 OC 调用，所以 data 是 OC 端传递过来的数据。
  3. responseCallback 。 JS 调用在被 OC 调用完毕之后，向 OC 端传递的数据。

基本就是：

OC 端注册 OC 的方法，OC 端调用 JS 的函数。
JS 端注册 JS 的函数，JS 端调用 OC 的方法。

五、原生与Web互调场景

1.JS -> OC 的交互

在 HTML 中，有个按钮，点击这个按钮，修改 NavigationBar 的颜色。

  1. 在 OC 端，往桥梁注入一个修改 NavigationBar 颜色的 block.
  2. 在 JS 端，调用这个 block，来间接的达到修改颜色的目的。

image.png

首先，在 OC 中，通过 WebViewJavascriptBridge 注册一个修改 navigationBar 颜色的 Block。

[_jsBridge registerHandler:@"colorClick" handler:^(id data, WVJBResponseCallback responseCallback) {
       self.navigationController.navigationBar.barTintColor = [UIColor colorWithRed:arc4random_uniform(256) / 255.0 green:arc4random_uniform(256) / 255.0 blue:arc4random_uniform(256) / 255.0 alpha:1.0];
        
        responseCallback(@"颜色修改完毕!");
    }];

然后再 JS 中，通过某种方式去调用这个 OC 的 block。

WebViewJavascriptBridge.callHandler('colorClick',function(dataFromOC) {
    alert("JS 调用了 OC 注册的 colorClick 方法");
    document.getElementById("returnValue").value = dataFromOC;
})

这里通过某种方式就是使用 WebViewJavascriptBridge.callHandler('OC 中block 别名',callback) 的方式来调用。

2.OC -> JS 的交互

OC 上有一个UIButton,点击这儿按钮，把 HTML body 的颜色修改成橙色。

首先，往桥梁中，注入一个修改 HTML body 颜色的 JSFunction。

// 在这里声明 OC 需要主动调用 JS 的方法。
setupWebViewJavascriptBridge(function(bridge) { 
      bridge.registerHandler('changeBGColor',function(data,responseCallback){
            // alert('aaaaaa');
            document.body.style.backgroundColor = "orange";
            document.getElementById("returnValue").value = data;
    });
});

然后在 OC 端通过桥梁调用这个 changeBGColor。

[_jsBridge callHandler:@"changeBGColor" data:@"把 HTML 的背景颜色改成橙色!!!!"];

执行效果：

image.png

六、补充

OC 调用 JS 的三种情况。

    // 单纯的调用 JSFunction，不往 JS 传递参数，也不需要 JSFunction 的返回值。
    [_jsBridge callHandler:@"changeBGColor"];
    // 调用 JSFunction，并向 JS 传递参数，但不需要 JSFunciton 的返回值。
    [_jsBridge callHandler:@"changeBGColor" data:@"把 HTML 的背景颜色改成橙色!!!!"];
    // 调用 JSFunction ，并向 JS 传递参数，也需要 JSFunction 的返回值。
    [_jsBridge callHandler:@"changeBGColor" data:@"传递给 JS 的参数" responseCallback:^(id responseData) {
        NSLog(@"JS 的返回值: %@",responseData);
    }];

JS 调用 OC 的三种情况。


// JS 单纯的调用 OC 的 block
WebViewJavascriptBridge.callHandler('scanClick');

// JS 调用 OC 的 block，并传递 JS 参数
WebViewJavascriptBridge.callHandler('scanClick',"JS 参数");

// JS 调用 OC 的 block，传递 JS 参数，并接受 OC 的返回值。
WebViewJavascriptBridge.callHandler('scanClick',{data : "这是 JS 传递到 OC 的扫描数据"},function(dataFromOC){
    alert("JS 调用了 OC 的扫描方法!");
    document.getElementById("returnValue").value = dataFromOC;
});

可以根据实际情况，选择合适的方法。

关于在 OC 中，往桥梁中注入 block 的注意点。

在当前控制器消失的时候，要记得把注入到桥梁中的 OC block，从桥梁中删除。
否则，可能会出现控制器无法释放的情况。

- (void)viewDidDisappear:(BOOL)animated {
    [super viewDidDisappear:animated];
    [_jsBridge removeHandler:@"scanClick"];
    [_jsBridge removeHandler:@"colorClick"];
    [_jsBridge removeHandler:@"locationClick"];
    [_jsBridge removeHandler:@"shareClick"];
    [_jsBridge removeHandler:@"payClick"];
    [_jsBridge removeHandler:@"goBackClick"];
}

最后总结：

  1. UIWebView & JavaScriptCore 等于原生的 JS & OC 交互方案。
  2. WKWebView & userContentController 等于原生了 JS & OC 交互方案。
  3. WebViewJavascriptBridge 可以搭配 UIWebView & WKWebView 进行 OC & JS 交互。
  4. WebViewJavascriptBridge 使用核心，OC 注入 OC 的方法，让 JS 调用。JS 注入 JS 函数，让 OC 调用。
  5. WebViewJavaScriptBridge 使用的需要 4个前提步骤。

推荐阅读

iOS事件的传递机制|【寻找事件最佳响应者、事件在响应者链上的传递】(转)

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

iOS的事件分为3大类型

  • Touch Events(触摸事件)
  • Motion Events(运动事件，比如重力感应和摇一摇等)
  • Remote Events(远程事件，比如用耳机上得按键来控制手机)

在开发中，最常用到的就是Touch Events(触摸事件) ，基本贯穿于每个App中，也是本文的主角~ 因此文中所说事件均特指触摸事件。

接下来，记录、涉及的问题大致包括：

  • 事件是怎么寻找事件的最佳响应者
  • 事件的响应及在响应链中的传递

寻找事件的最佳响应者（Hit-Testing）

当我们触摸屏幕的某个可响应的功能点后，最终都会由UIView或者继承UIView的控件来响应

那我们先来看下UIView的两个方法：


 // recursively calls -pointInside:withEvent:. point is in the receiver's coordinate system
//返回寻找到的最终响应这个事件的视图
- (nullable UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event;  

// default returns YES if point is in bounds
//判断某一个点击的位置是否在视图范围内
- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event;

每个UIView对象都有一个 hitTest: withEvent: 方法，这个方法是Hit-Testing过程中最核心的存在，其作用是询问事件在当前视图中的响应者，同时又是作为事件传递的桥梁。

看看它是什么时候被调用的

  • 当手指接触屏幕，UIApplication接收到手指的触摸事件之后，就会去调用UIWindow的hitTest: withEvent:方法
  • 在hitTest: withEvent:方法中会调用pointInside: withEvent:去判断当前点击的point是否属于UIWindow范围内，如果是，就会以倒序的方式遍历它的子视图，即越后添加的视图，越先遍历
  • 子视图也调用自身的hitTest: withEvent:方法，来查找最终响应的视图

再来看个示例：

视图层级如下（同一层级的视图越在下面，表示越后添加）：


A
├── B
│   └── D
└── C
    ├── E
    └── F

现在假设在E视图所处的屏幕位置触发一个触摸，App接收到这个触摸事件事件后，先将事件传递给UIWindow，然后自下而上开始在子视图中寻找最佳响应者。事件传递的顺序如下所示：

  • UIWindow将事件传递给其子视图A
  • A判断自身能响应该事件，继续将事件传递给C（因为视图C比视图B后添加，因此优先传给C）。
  • C判断自身能响应事件，继续将事件传递给F（同理F比E后添加）。
  • F判断自身不能响应事件，C又将事件传递给E。
  • E判断自身能响应事件，同时E已经没有子视图，因此最终E就是最佳响应者。

以上，就是寻找最佳响应者的整个过程。

接下来，来看下hitTest: withEvent:方法里，都做些了什么？

我们已经知道事件在响应者之间的传递，是视图通过判断自身能否响应事件来决定是否继续向子视图传递，那么判断响应的条件是什么呢？

视图响应事件的条件：

  • 允许交互： userInteractionEnabled = YES
  • 禁止隐藏：hidden = NO
  • 透明度：alpha > 0.01
  • 触摸点的位置：通过 pointInside: withEvent:方法判断触摸点是否在视图的坐标范围内

代码的表现大概如下：


- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    //3种状态无法响应事件
    if (!self.isUserInteractionEnabled || self.isHidden || self.alpha <= 0.01) {
        return nil;
    }

     //触摸点若不在当前视图上则无法响应事件
    if ([self pointInside:point withEvent:event]) {
         //从后往前遍历子视图数组
        for (UIView *subView in [self.subviews reverseObjectEnumerator]) {
            // 坐标系的转换,把触摸点在当前视图上坐标转换为在子视图上的坐标
            CGPoint convertedPoint = [subView convertPoint:point fromView:self];
             //询问子视图层级中的最佳响应视图
            UIView *hitTestView = [subView hitTest:convertedPoint withEvent:event];
            if (hitTestView) {
                 //如果子视图中有更合适的就返回
                return hitTestView;
            }
        }
         //没有在子视图中找到更合适的响应视图，那么自身就是最合适的
        return self;
    }

    return nil;
}

说了这么多，那我们可以运用hitTest: withEvent:来搞些什么事情呢

使超出父视图坐标范围的子视图也能响应事件

视图层级如下:

css

A
├── B

如上图所示，视图B有一部分是不在父视图A的坐标范围内的，当我们触摸视图B的上半部分，是不会响应事件的。当然，我们可以通过重写视图A的 hitTest: withEvent:方法来解决这个需求。


- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    UIView *view = [super hitTest:point withEvent:event];
    //如果找不到合适的响应者
    if (view == nil) {
        //视图B坐标系的转换
        CGPoint newPoint = [self.deleteButton convertPoint:point fromView:self];
        if (CGRectContainsPoint(self.deleteButton.bounds, newPoint)) {
            // 满足条件,返回视图B
            view = self.deleteButton;
        }
    }

    return view;
}

在视图A的hitTest: withEvent:方法中判断触摸点，是否位于视图B的视图范围内，如果属于，则返回视图B。这样一来，当我们点击视图B的任何位置都可以响应事件了。

事件的响应及在响应链中的传递

经历Hit-Testing后，UIApplication已经知道事件的最佳响应者是谁了，接下来要做的事情就是：

  • 将事件传递给最佳响应者响应
  • 事件沿着响应链传递

事件传递给最佳响应者

最佳响应者具有最高的事件响应优先级，因此UIApplication会先将事件传递给它供其响应。

UIApplication中有个sendEvent:的方法，在UIWindow中同样也可以发现一个同样的方法。UIApplication是通过这个方法把事件发送给UIWindow，然后UIWindow通过同样的接口，把事件发送给最佳响应者。

以寻找事件的最佳响应者一节中点击视图E为例，在EView的 touchesBegan:withEvent: 上打个断点查看调用栈就能看清这一过程：

当事件传递给最佳响应者后，响应者响应这个事件，则这个事件到此就结束了，它会被释放。假设响应者没有响应这个事件，那么它将何去何从？事件将会沿着响应链自上而下传递。

注意： 寻找最佳响应者一节中也说到了事件的传递，与此处所说的事件的传递有本质区别。上面所说的事件传递的目的是为了寻找事件的最佳响应者，是自下而上（父视图到子视图）的传递；而这里的事件传递目的是响应者做出对事件的响应，这个过程是自上而下（子视图到父视图）的。前者为“寻找”，后者为“响应”。

事件沿着响应链传递

在UIKit中有一个类：UIResponder，它是所有可以响应事件的类的基类。来看下它的头文件的几个属性和方法


NS_CLASS_AVAILABLE_IOS(2_0) @interface UIResponder : NSObject <UIResponderStandardEditActions>

#if UIKIT_DEFINE_AS_PROPERTIES
@property(nonatomic, readonly, nullable) UIResponder *nextResponder;
#else
- (nullable UIResponder*)nextResponder;
#endif

--------------省略部分代码------------

  // Generally, all responders which do custom touch handling should override all four of these methods.
// Your responder will receive either touchesEnded:withEvent: or touchesCancelled:withEvent: for each
// touch it is handling (those touches it received in touchesBegan:withEvent:).
// *** You must handle cancelled touches to ensure correct behavior in your application.  Failure to
// do so is very likely to lead to incorrect behavior or crashes.
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event;
- (void)touchesEstimatedPropertiesUpdated:(NSSet<UITouch *> *)touches NS_AVAILABLE_IOS(9_1);

UIApplication，UIViewController和UIView都是继承自它，都有一个 nextResponder 方法，用于获取响应链中当前对象的下一个响应者，也通过nextResponder来串成响应链。

在App中，所有的视图都是根据树状层次结构组织起来的，因此，每个View都有自己的SuperView。当一个View被add到SuperView上的时候，它的nextResponder属性就会被指向它的SuperView，各个不同响应者的指向如下：

  • UIView 若视图是控制器的根视图，则其nextResponder为控制器对象；否则，其nextResponder为父视图。
  • UIViewController 若控制器的视图是window的根视图，则其nextResponder为窗口对象；若控制器是从别的控制器present出来的，则其nextResponder为presenting view controller。
  • UIWindow nextResponder为UIApplication对象。
  • UIApplication 若当前应用的app delegate是一个UIResponder对象，且不是UIView、UIViewController或app本身，则UIApplication的nextResponder为app delegate。

这样，整个App就通过nextResponder串成了一条链，也就是我们所说的响应链，子视图指向父视图构成的响应链。

看一下官网对于响应链的示例展示

若触摸发生在UITextField上，则事件的传递顺序是：

  • UITextField ——> UIView ——> UIView ——> UIViewController ——> UIWindow ——> UIApplication ——> UIApplicationDelegte

图中虚线箭头是指若该UIView是作为UIViewController根视图存在的，则其nextResponder为UIViewController对象；若是直接add在UIWindow上的，则其nextResponder为UIWindow对象。

响应者对于事件的拦截以及传递都是通过 touchesBegan:withEvent: 方法控制的，该方法的默认实现是将事件沿着默认的响应链往下传递。

响应者对于接收到的事件有3种操作：

  • 不拦截，默认操作 事件会自动沿着默认的响应链往下传递
  • 拦截，不再往下分发事件 重写 touchesBegan:withEvent: 进行事件处理，不调用父类的 touchesBegan:withEvent:
  • 拦截，继续往下分发事件 重写 touchesBegan:withEvent: 进行事件处理，同时调用父类的 touchesBegan:withEvent: 将事件往下传递

因此，你也可以通过 touchesBegan:withEvent:方法搞点事情~

总结

触摸事件先通过自下而上(父视图-->子视图)的传递方式寻找最佳响应者，

然后以自上而下(子视图-->父视图)的方式在响应链中传递。

iOS多环境配置(转)

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

基本概念

  • Project：包含了项⽬所有的代码，资源⽂件，所有信息。
  • Target：对指定代码和资源⽂件的具体构建方式。
  • Scheme：对指定Target的环境配置。

通过不同的方式配置多环境

通过Duplicate Target方式配置

  • 通过上述操作之后会多生成一个target，也会多出来一个info.plist

  • 可以定义一个宏的方式，对代码做一些差异化的配置

  • oc在build setting->Preprocessor Macros

  • swift在build setting->Other Swift Flags，需要注意的是swift中使用宏需要加上-D参数

  • 这种方式配置起来缺点

    • 生成多个info.plist
    • 需要配置的点比较多，比较乱

通过配置Scheme的方式

  • 再通过Edit Scheme->Manage Schemes新增不同环境的scheme
  • 再将不同的Scheme对应到不同的Build Configuration模式下

使用场景举例

  • 在日常开发中，不同环境下的host url的地址都会有不同的差异,通过定义一个宏的方式

  • 再通过info.plist文件暴露出来

  • 使用方式如下
NSString *path = [[NSBundle mainBundle] pathForResource:@"Info" ofType:@".plist"];
NSDictionary *infoDict = [[NSDictionary alloc] initWithContentsOfFile:path];
NSLog(@"host url:%@",infoDict[@"HOST_URL"]);
复制代码

xcconfig文件

xcconfig指南

  • xcconfig文件的语法比较简单，每个配置文件都由一系列键值分配组成，这些键值分配具有以下语法：
BUILD_SETTING_NAME = value
复制代码

注释

  • xcconfig文件只有一种注释方式\。

include导入其他设置

  • 在创建xcconfig文件的时候，可以根据需求，创建多个。也就意味着，可以通过include关键字导入其他的xcconfig内的配置。通过include关键字后接上双引号：
#include "Debug.xcconfig"
复制代码
  • 在搜索引入的文件时，如果是以/开头，代表绝对路径，例如：
// 表示确切的文件位置
#include "/Users/xx/Desktop/.../xxx.xcconfig"
复制代码
  • 或者通过相对路径，以${SRCROOT}路径为开始：
#include "Pods/Target Support Files/xxx.xcconfig"
复制代码

变量

  • 变量定义，按照OC命名规则，仅由大写字母，数字和下划线（_）组成，原则上大写，也可以不。字符串可以是"也可以是'号。

  • 变量有三种特殊情况：

      1. 在xcconfig中定义的变量与Build Settings的一致，那么会发生覆盖。可以通过$(inherited)，让当前变量继承变量原有值。例如：
    OTHER_LDFLAGS = -framework SDWebImage
OTHER_LDFLAGS = $(inherited) -framework AFNetworking
// OTHER_LDFLAGS = -framework SDWebImage -framework AFNetworking
复制代码

    注意⚠️：有部分变量不能通过xcconfig配置到Build Settings中，例如：配	 置PRODUCT_BUNDLE_IDENTIFIER不起作用。
复制代码
      1. 引用变量，$()和${}两种写法都可以：VALUE=value 
    TEACHER=$(VALUE)-${VALUE}
复制代码
      1. 条件变量，根据SDK、Arch和Configration对设置进行条件化，例如：
    // 指定`Configration`是`Debug`
// 指定`SDK`是模拟器，还有iphoneos*、macosx*等
// 指定生效架构为`x86_64`
OTHER_LDFLAGS[config=Debug][sdk=iphonesimulator*[arch=x86_64]= $(inherited) -framework "Cat"
复制代码

    注意⚠️：在Xcode 11.4及以后版本，可以使用default，来指定变量为空时的默认值：
$(BUILD_SETTING_NAME:default=value)
复制代码

优先级（由高到低）：

    1. 手动配置Target Build Settings
    1. Target中配置的xcconfig文件
    1. 手动配置Project Build Settings
    1. Project中配置的xcconfig文件

iOS蓝牙知识快速入门（详尽版）(转)

✇掘金专栏-没有故事的Zhang同学
没有故事的Zhang同学

iOS-bluetooth

以前写过几篇蓝牙相关的文章，但是没有涉及扫描、收发指令这些基础功能的实现。所以打算写一篇尽可能详尽的蓝牙知识汇总，一方面给有需要的同学看，一方面是对自己学习蓝牙的一个总结。

这篇文章的目的：教你实现设备的扫描，连接，数据收发，蓝牙数据解析。如果在实现上面任一功能遇到问题时，欢迎留下你的问题，我将进行补充，对于说法有误的地方也请老司机予以指正。

目录

0、思维导图

1、苹果对蓝牙设备有什么要求

2、操作蓝牙设备使用什么库

3、如何扫描

4、如何连接

5、如何发送数据和接收数据

6、如何解析数据

7、扩展

思维导图

思维导图

第一次做图，大家凑合着看哈。这张是我总结的蓝牙知识的结构图，下面的内容将围绕这些东西展开进行。

连接设备流程

这张是蓝牙连接发送数据的流程图，下文进入coding阶段的讲解顺序，大家先有个大概印象，等阅读完本文再回来看这张图将理解的更深一些。

苹果对蓝牙设备有什么要求

BLE：bluetouch low energy，蓝牙4.0设备因为低功耗，所有也叫作BLE。苹果在iphone4s及之后的手机型号开始支持蓝牙4.0，这也是最常见的蓝牙设备。低于蓝牙4.0协议的设备需要进行MFI认证，关于MFI认证的申请工作可以看这里：关于MFI认证你所必须要知道的事情

在进行操作蓝牙设备前，我们先下载一个蓝牙工具LightBlue，它可以辅助我们的开发，在进行蓝牙开发之前建议先熟悉一下LightBlue这个工具。

操作蓝牙设备使用什么库

苹果自身有一个操作蓝牙的库CoreBluetooth.framework，这个是大多数人员进行蓝牙开发的首选框架，除此之外目前github还有一个比较流行的对原生框架进行封装的三方库BabyBluetooth，它的机制是将CoreBluetooth中众多的delegate写成了block方法，有兴趣的同学可以了解下。下面主要介绍的是原生蓝牙库的知识。

中心和外围设备

central-peripheral

如图所示，电脑、Pad、手机作为中心，心跳监听器作为外设，这种中心外设模式是最常见的。简单理解就是，发起连接的是中心设备（Central），被连接的是外围设备（Peripheral），对应传统的客户机-服务器体系结构。Central能够扫描侦听到，正在播放广告包的外设。

服务与特征

外设可以包含一个或多个服务（CBService），服务是用于实现装置的功能或特征数据相关联的行为集合。 而每个服务又对应多个特征（CBCharacteristic）,特征提供外设服务进一步的细节，外设，服务，特征对应的数据结构如下所示

CBService-CBCharacteristic

如何扫描蓝牙

在进行扫描之前我们需要，首先新建一个类作为蓝牙类，例如FYBleManager，写成单例，作为处理蓝牙操作的管理类。引入头文件#import <CoreBluetooth/CoreBluetooth.h> CBCentralManager是蓝牙中心的管理类，控制着蓝牙的扫描，连接，蓝牙状态的改变。

1、初始化

dispatch_queue_t centralQueue = dispatch_queue_create(“centralQueue",DISPATCH_QUEUE_SERIAL);

NSDictionary *dic = @{
    CBCentralManagerOptionShowPowerAlertKey : YES,
    CBCentralManagerOptionRestoreIdentifierKey : @"unique identifier"
};

self.centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:centralQueue options:dic];
  • CBCentralManagerOptionShowPowerAlertKey对应的BOOL值，当设为YES时，表示CentralManager初始化时，如果蓝牙没有打开，将弹出Alert提示框
  • CBCentralManagerOptionRestoreIdentifierKey对应的是一个唯一标识的字符串，用于蓝牙进程被杀掉恢复连接时用的。

2、扫描

//不重复扫描已发现设备
NSDictionary *option = @{
    CBCentralManagerScanOptionAllowDuplicatesKey : [NSNumber numberWithBool:NO],
    CBCentralManagerOptionShowPowerAlertKey:YES
};

[self.centralManager scanForPeripheralsWithServices:nil options:option];
- (void)scanForPeripheralsWithServices:(nullable NSArray<CBUUID *> *)serviceUUIDs options:(nullable NSDictionary<NSString *, id> *)options;
  • 扫面方法
    • serviceUUIDs用于第一步的筛选，扫描此UUID的设备
    • options有两个常用参数：
      • CBCentralManagerScanOptionAllowDuplicatesKey
        • 设置为NO表示不重复扫瞄已发现设备，为YES就是允许
      • CBCentralManagerOptionShowPowerAlertKey
      • 设置为YES就是在蓝牙未打开的时候显示弹框

3、CBCentralManagerDelegate代理方法

在初始化的时候我们调用了代理，在CoreBluetooth中有两个代理，

  • CBCentralManagerDelegate
  • CBPeripheralDelegate

iOS的命名很友好，我们通过名字就能看出，上面那个是关于中心设备的代理方法，下面是关于外设的代理方法。
我们这里先研究CBCentralManagerDelegate中的代理方法

- (void)centralManagerDidUpdateState:(CBCentralManager *)central;

这个方法标了@required是必须添加的，我们在self.centralManager初始换之后会调用这个方法，回调蓝牙的状态。状态有以下几种：

typedef NS_ENUM(NSInteger, CBCentralManagerState{
    CBCentralManagerStateUnknown = CBManagerStateUnknown,//未知状态
    CBCentralManagerStateResetting = CBManagerStateResetting,//重启状态
    CBCentralManagerStateUnsupported = CBManagerStateUnsupported,//不支持
    CBCentralManagerStateUnauthorized = CBManagerStateUnauthorized,//未授权
    CBCentralManagerStatePoweredOff = CBManagerStatePoweredOff,//蓝牙未开启
    CBCentralManagerStatePoweredOn = CBManagerStatePoweredOn,//蓝牙开启} NS_DEPRECATED(NA, NA, 5_0, 10_0, "Use CBManagerState instead”
);

该枚举在iOS10之后已经废除了，系统推荐使用CBManagerState，类型都是对应的

typedef NS_ENUM(NSInteger, CBManagerState{
    CBManagerStateUnknown = 0,
    CBManagerStateResetting,
    CBManagerStateUnsupported,
    CBManagerStateUnauthorized,
    CBManagerStatePoweredOff,
    CBManagerStatePoweredOn,
} NS_ENUM_AVAILABLE(NA, 10_0);

- (void)centralManager:(CBCentralManager *)central 
    didDiscoverPeripheral:(CBPeripheral *)peripheral
    advertisementData:(NSDictionary<NSString *, id> *)advertisementData RSSI:(NSNumber *)RSSI;
  • peripheral是外设类
  • advertisementData是广播的值，一般携带设备名，serviceUUIDs等信息
  • RSSI绝对值越大，表示信号越差，设备离的越远。如果想转换成百分比强度，（RSSI+100）/100，（这是一个约数，蓝牙信号值并不一定是-100 - 0的值，但近似可以如此表示）
- (void)centralManager:(CBCentralManager *)central willRestoreState:(NSDictionary<NSString *, id> *)dict;

在蓝牙于后台被杀掉时，重连之后会首先调用此方法，可以获取蓝牙恢复时的各种状态

如何连接

在扫面的代理方法中，我们连接外设名是MI的蓝牙设备

- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI{ 
    NSLog(@"advertisementData:%@，RSSI:%@",advertisementData,RSSI);
    if([peripheral.name isEqualToString:@"MI"]){ 
        [self.centralManager connectPeripheral:peripheral options:nil];//发起连接的命令
        self.peripheral = peripheral; 
    }
}

连接的状态 对应另外的CBCentralManagerDelegate代理方法 连接成功的回调

- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral;

连接失败的回调

- (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(nullable NSError *)error;

连接断开的回调

- (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(nullable NSError *)error;

连接成功之后并没有结束，还记得CBPeripheral中的CBService和CBService中的CBCharacteristic吗，对数据的读写是由CBCharacteristic控制的。
我们先用lightblue连接小米手环为例，来看一下，手环内部的数据是不是我们说的那样。

lightblue

其中ADVERTISEMENT DATA显示的就是广播信息。

iOS蓝牙无法直接获取设备蓝牙MAC地址，可以将MAC地址放到这里广播出来

FEEO是ServiceUUIDs,里面的FF01、FF02是CBCharacteristic的UUID

Properties是特征的属性，可以看出FF01具有读的权限，FF02具有读写的权限。
特征拥有的权限类别有如下几种：

typedef NS_OPTIONS(NSUInteger, CBCharacteristicProperties{
    CBCharacteristicPropertyBroadcast = 0x01,
    CBCharacteristicPropertyRead = 0x02,
    CBCharacteristicPropertyWriteWithoutResponse = 0x04,
    CBCharacteristicPropertyWrite = 0x08,
    CBCharacteristicPropertyNotify = 0x10,
    CBCharacteristicPropertyIndicate = 0x20,
    CBCharacteristicPropertyAuthenticatedSignedWrites = 0x40,
    CBCharacteristicPropertyExtendedProperties = 0x80,
    CBCharacteristicPropertyNotifyEncryptionRequired NS_ENUM_AVAILABLE(NA, 6_0) = 0x100,
    CBCharacteristicPropertyIndicateEncryptionRequired NS_ENUM_AVAILABLE(NA, 6_0) = 0x200
};

如何发送并接收数据

通过上面的步骤我们发现CBCentralManagerDelegate提供了蓝牙状态监测、扫描、连接的代理方法，但是CBPeripheralDelegate的代理方法却还没使用。别急，马上就要用到了，通过名称判断这个代理的作用，肯定是跟Peripheral有关，我们进入系统API，看它的代理方法都有什么，因为这里的代理方法较多，我就挑选几个常用的拿出来说明一下。

1、代理方法 

//发现服务的回调
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(nullable NSError *)error;
//发现特征的回调
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(nullable NSError *)error;
//读数据的回调
- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(nullable NSError *)error;
//是否写入成功的回调
- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic error:(nullable NSError *)error;

2、步骤

通过这几个方法我们构建一个流程：连接成功->获取指定的服务->获取指定的特征->订阅指定特征值->通过具有写权限的特征值写数据->在didUpdateValueForCharacteristic回调中读取蓝牙反馈值

解释一下订阅特征值：特征值具有Notify权限才可以进行订阅，订阅之后该特征值的value发生变化才会回调didUpdateValueForCharacteristic

3、实现上面流程的实例代码 

//连接成功
- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral{
    //连接成功之后寻找服务，传nil会寻找所有服务
    [peripheral discoverServices:nil];
}

//发现服务的回调
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error{
   if (!error) { 
     for (CBService *service in peripheral.services) {     
         NSLog(@"serviceUUID:%@", service.UUID.UUIDString); 
            if ([service.UUID.UUIDString isEqualToString:ST_SERVICE_UUID]) {
            //发现特定服务的特征值
               [service.peripheral discoverCharacteristics:nil forService:service]; 
            } 
        } 
    }
}

//发现characteristics，由发现服务调用（上一步），获取读和写的characteristics
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error {
    for (CBCharacteristic *characteristic in service.characteristics) { 
        //有时读写的操作是由一个characteristic完成 
        if ([characteristic.UUID.UUIDString isEqualToString:ST_CHARACTERISTIC_UUID_READ]) {
            self.read = characteristic;
            [self.peripheral setNotifyValue:YES forCharacteristic:self.read]; 
        } else if ([characteristic.UUID.UUIDString isEqualToString:ST_CHARACTERISTIC_UUID_WRITE]) {
            self.write = characteristic; 
        } 
     }
}

//是否写入成功的代理
- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error{
    if (error) { 
        NSLog(@"===写入错误：%@",error); 
    }else{
        NSLog(@"===写入成功"); 
    }
}

//数据接收
- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error { 
    if([characteristic.UUID.UUIDString isEqualToString:ST_CHARACTERISTIC_UUID_READ]){          //获取订阅特征回复的数据
        NSData *value = characteristic.value;
        NSLog(@"蓝牙回复：%@",value);
    }
}

比如我们要获取蓝牙电量，由硬件文档查询得知该指令是 0x1B9901,那么获取电量的方法就可以写成

- (void)getBattery{
    Byte value[3]={0};
    value[0]=x1B;
    value[1]=x99;
    value[2]=x01;
    NSData * data = [NSData dataWithBytes:&value length:sizeof(value)];
    //发送数据
    [self.peripheral writeValue:data forCharacteristic:self.write type:CBCharacteristicWriteWithoutResponse];
}

如果写入成功，我们将会在didUpdateValueForCharacteristic方法中获取蓝牙回复的信息。

如何解析蓝牙数据

如果你顺利完成了上一步的操作，并且看到了蓝牙返回的数据，那么恭喜你，蓝牙的常用操作你已经了解大半了。因为蓝牙的任务大部分就是围绕发送指令，获取指令，将蓝牙数据呈现给用户。上一步我们已经获取了蓝牙指令，但是获取的却是0x567b0629这样的数据，这是什么意思呢。这时我们参考硬件协议文档，看到这样一段:

device-document

那么我们就可以得出设备电量是 60%。

对数据解析的流程就是：

  • 判断校验和是否正确
    • 是不是一条正确的数据->该条数据是不是我们需要的电量数据
    • 即首字节为0x567b->根据定义规则解析电量，传给view显示。
  • 其中第一步校验数据，视情况而定，也有不需要的情况。

扩展

iOS蓝牙中的进制转换

蓝牙固件升级

nRF芯片设备DFU升级

参考Demo

❌