(IOS) 向Hero致敬與分析 (二) - Double研究所

本篇继上篇:http://www.jianshu.com/p/fdab69f7440a
本篇种点:

  • Plugin
  • heroModifierString

1.3.1)Present流程 - start() - Plugin, HeroPreprocessor , HeroAnimator


public func animateTransition(using context: UIViewControllerContextTransitioning) {
 /*
 略
.
*/
 start()
}

我们来到最主要的程式段:start()

func start() {
    plugins == nil {
      print("plugins == nil")
     //把enabledPlugins里的每个类别全部init后放进
      plugins = Hero.enabledPlugins.map({ return $0.init() })
    }
 /*
 略
.
*/
}

一开头就是我们没见过的plugins这个变数,所以我们先来浅谈plugins是什么。

Plugin是Hero提供可以让使用者、开发者自行在做自定义的处理动画或是其他变数处理。只要让类别实作HeroPlugin(继承HeroPreprocessor, HeroAnimator两个协定)这个类别,即可在过场的进行时,收到以下通知:

Hero's Plugin


现在我们来看看HeroPreprocessor, HeroAnimator
Hero有以下两个变数,可以把它们想成两条线程,一条专门做一系列的HeroPreprocessor, 而另一条则做一系列的HeroAnimator。上面提到的Plugin同时属于这两类。

 var processors: [HeroPreprocessor]!
 var animators: [HeroAnimator]!

func start() {
/* 略 */
processors = Hero.builtInProcessors  //Hero内建程序
animators = Hero.builtInAnimator    //Hero内建动画

 // 如果有插件的话就加进程序
    for plugin in plugins {
      processors.append(plugin)
      animators.append(plugin)
    }
/* 略 */
// ask each preprocessor to process
    for processor in processors {
      processor.process(context:context, fromViews: context.fromViews, toViews: context.toViews)
    }
/* 略 */
 for animator in animators.reversed() {
      let currentFromViews = fromViews.filterInPlace{ [context] (view:UIView) -> Bool in
        return !animator.canAnimate(context: context!, view: view, appearing: false)
      }
      let currentToViews = toViews.filterInPlace{ [context] (view:UIView) -> Bool in
        return !animator.canAnimate(context: context!, view: view, appearing: true)
      }
      animatorViews.insert((currentFromViews, currentToViews), at: 0)
    }
}

1.3.2)Present流程 - start() - 制作过场"舞台"


复制一个起始view(from view)盖上去(animatingViewContainer),之后所有动画都在上面进行,算是最好懂的一块。

func start() {
/* 略 */
transitionContainer.isUserInteractionEnabled = false
    // a view to hold all the animation views
    //transitionContainer是在context拿到的
    animatingViewContainer = UIView(frame: transitionContainer.bounds)
    transitionContainer.addSubview(animatingViewContainer) //加上一个空的等大容器
    // create a snapshot view to hide all the flashing that might happen
    let completeSnapshot = fromView.snapshotView(afterScreenUpdates: true)!
    transitionContainer.addSubview(completeSnapshot)
    
    animatingViewContainer.addSubview(fromView)
    animatingViewContainer.insertSubview(toView, belowSubview: fromView)
    animatingViewContainer.backgroundColor = toView.backgroundColor
/* 略 */

context = HeroContext(container:animatingViewContainer, fromView: fromView, toView:toView)
}

1.4)HeroContext


这个类别算是Hero的特色也是最有技巧性的一部分。主要处理这两个 "HeroID", "heroModifierString"

1.4.1) heroModifierString

一句话概括它,就是“指令”,指示这个View要执行怎样的过场动画。使用者在StoryBoard或是swift里给定ModifierString后,即在变数的set{...}将字串转为可执行的function指令。

public extension UIView{
  /* 略 */
@IBInspectable public var heroModifierString: String? {
  /* 略 */
      let modifierString = newValue as NSString
      var modifiers = [HeroModifier]() //function结果
      //modifiersRegex = "(\\w+)(?:\\(([^\\)]*)\\))?"
      for r in matches(for: modifiersRegex, text:modifierString) //A Loop
      {
        var parameters = [String]()
        if r.numberOfRanges > 2, r.rangeAt(2).location < modifierString.length
        {
          let parameterString = modifierString.substring(with: r.rangeAt(2)) as NSString
          //parameterRegex = "(?:\\-?\\d+(\\.?\\d+)?)|\\w+"
          for r in matches(for: parameterRegex, text: parameterString){ //B Loop
            parameters.append(parameterString.substring(with: r.range))
          }
        }
        let name = modifierString.substring(with: r.rangeAt(1))
        //取得Function
        if let modifier = HeroModifier.from(name: name, parameters: parameters){
          modifiers.append(modifier)
       /*略*/

numberOfRanges:regx的组数,最外层()的数量。

rangeAt(0) = 有符合的结果, rangeAt(1) = 有一组以上,rangeAt(2) = 有两组以上......

A Loop: 找出 一个以上非空白 可能出现一对括号 中间夹着多个非右括号 = 一个Fuction的格式 , 若 numberOfRanges > 2 则代表有(参数)。
B Loop: 参数 可是一串非空白 或是 数子(可负数或小数)

EX: heroModifierString = zPosition(2) arc

parameterString = 2 , name = zPosition
name = arc

读出个别指令后就是利用一个配对Function,可以看到最终每个字串有配对结果的话,可以得到一个个的"闭包(Closure)"

public class HeroModifier {
  internal let apply:(inout HeroTargetState) -> Void
  public init(applyFunction:@escaping (inout HeroTargetState) -> Void){
    apply = applyFunction
  }
/*略*/
static func from(name:String, parameters:[String]) -> HeroModifier?
{

switch name {
    case "zPosition": 
      if let zPosition = parameters.getCGFloat(0){ //拿参数
        modifier = .zPosition(zPosition)
      }
}
/*略*/
public static func zPosition(_ zPosition:CGFloat) -> HeroModifier {
    return HeroModifier { targetState in
      targetState.zPosition = zPosition
    }
  }
}
/*略*/
 public static func arc(intensity:CGFloat = 1) -> HeroModifier {
    return HeroModifier { targetState in
      targetState.arc = intensity
    }
  }

走到这么深之后,我们现在在回extension UIView顶层看看另外一个扩充变数,

public extension UIView{
/*略*/
public var heroModifiers: [HeroModifier]? 

现在我们可以把它理解成一个可执行的闭包集合,因为每个HeroModifier都自带一个闭包

apply:(inout HeroTargetState) -> Void

它记着一个View在过场时,所有要执行的过场动画,可利用
modifier.apply(&HeroTargetState)呼叫。

推荐阅读更多精彩内容