JKPacket权威指南——学习建议

Lifecycle简介

  Lifecycle：顾名思义就是生命周期，iOS中具有生命周期的概念有：UIApplication，UIViewController,UIView等。我们基于工作经验可以整理出lifecycle的不同阶段如下：
1，创建：create
2，开始： start
3，恢复 ：resume(active)
4，暂停：pause
5，停止： stop
6，销毁：destroy
示意图如下：

处于活跃的阶段：
resume -> pause
其余阶段都处于非活跃状态。

  在日常的开发过程中，我们经常会遇到这样的需求：接收到一个数据，在页面活跃的时候，需要根据接收到的数据执行计算、刷新等相关的操作，在页面不活跃的时候，接收到了数据直接忽略，或者等到下次页面活跃的时候执行后续操作。如果不考虑页面是否活跃直接处理会有两种情况，1）会与当前处于活跃状态的页面抢占计算机资源，2）处于不活跃状态时执行结果异常。 但是如果有很多这样的情况需要处理是，会增加开发的记忆负担，需要维护很多的状态。

JKLifeCycleViewController基于Lifecycle实现对UIViewController态变化的监听

Lifecycle通过JKLifecycleRegistry，JKLifecycleOwner这两个协议实现观察者模式监听页面属性的变化，实现降低页面与组件的耦合，具体实现如下：
监听代码：

public override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
        mLifecycleRegistry = JKLifecycleRegistry(provider: self)
        let lifecycle:JKLifecycle = getLifecycle()
        let _ = lifecycle.addObserve {[weak self] source, event in
            if event == .ON_STOP {
//                取消第一响应者，不再响应输入事件
                self?.resignFirstResponder()
            }
        }
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_CREATE)
    }

1
2
3
4
5
6
7
8
9
10
11
12
13

页面改变状态需要主动的通过mLifecycleRegistry来触发事件，具体如下：

open override func viewDidLoad() {
        super.viewDidLoad()
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_START)
    }
    
    open override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_RESUME)
    }
    
    open override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_PAUSE)
    }
    
    open override func didMove(toParent parent: UIViewController?) {
        super.didMove(toParent: parent)
        if parent == nil {
            mLifecycleRegistry?.handleLifecycleEvent(event: .ON_STOP)
        }
    }
    
    open override func dismiss(animated flag: Bool, completion: (() -> Void)? = nil) {
        super.dismiss(animated: flag) {
            self.mLifecycleRegistry?.handleLifecycleEvent(event: .ON_STOP)
            completion?()
        }
    }
    
    deinit {
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_DESTROY)
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

JKLifeCycleView基于Lifecycle实现对应用生命周期状态变化的监听

监听view生命周期状态变化的代码如下：

private func initLifecycle() {
        mLifecycleRegistry = JKLifecycleRegistry(provider: self)
        let lifecycle:JKLifecycle = getLifecycle()
        let _ = lifecycle.addObserve { [weak self] source, event in
            if event == .ON_STOP {
//                取消第一响应者，不再响应输入事件
                self?.resignFirstResponder()
            }
        }
    }
1
2
3
4
5
6
7
8
9
10

View生命周期发生变化时使用主动触发变化：

public override init(frame: CGRect) {
        super.init(frame: frame)
        initLifecycle()
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_CREATE)
    }
    
    required public init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    public override func didMoveToSuperview() {
        super.didMoveToSuperview()
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_START)
    }
    
    public override func didMoveToWindow() {
        super.didMoveToWindow()
        if window != nil {
            mLifecycleRegistry?.handleLifecycleEvent(event: .ON_RESUME)
        } else {
            mLifecycleRegistry?.handleLifecycleEvent(event: .ON_PAUSE)
        }
    }
    

    public override func removeFromSuperview() {
        super.removeFromSuperview()
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_STOP)
    }
    
    deinit {
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_DESTROY)
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

JKProcessLifecycleOwner基于Lifecycle实现对应用生命周期状态变化的监听

通过将应用生命周期状态变化转化为lifecycle的状态变化，并通过监听状态变化来实现更多的后续操作，具体实现如下：

 mLifecycleRegistry = JKLifecycleRegistry(provider: self)
        let lifecycle:JKLifecycle = getLifecycle()
        let _ = lifecycle.addObserve { [weak self] source, event in
            if event == .ON_STOP {
//                取消第一响应者，不再响应输入事件
                self?.resignFirstResponder()
            }
        }
1
2
3
4
5
6
7
8

UIApplication生命周期发生变化的时候主动触发变化

 override init () {
        super.init()
        mLifecycleRegistry = JKLifecycleRegistry(provider: self)
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_CREATE)
    }
    
    public static func setup() {
        let instance = JKProcessLifecycleOwner.shared
        NotificationCenter.default.addObserver(instance, selector: #selector(applicationBecomeActive(_ :)), name: UIApplication.didBecomeActiveNotification, object: nil)
        NotificationCenter.default.addObserver(instance, selector: #selector(applicationDidEnterBackground(_ :)), name: UIApplication.didEnterBackgroundNotification, object: nil)
        NotificationCenter.default.addObserver(instance, selector: #selector(applicationWillTerminate(_ :)), name: UIApplication.willTerminateNotification, object: nil)
        JKProcessLifecycleOwner.shared.mLifecycleRegistry?.handleLifecycleEvent(event: .ON_START)
    }
    
    
    @objc private func applicationBecomeActive(_ notification:Notification) {
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_RESUME)
    }
    
    @objc private func applicationDidEnterBackground(_ notification:Notification) {
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_PAUSE)
    }
    
    @objc private func applicationWillTerminate(_ notification:Notification) {
        mLifecycleRegistry?.handleLifecycleEvent(event: .ON_DESTROY)
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

总结：JKLifeCycleViewController，JKLifeCycleView，JKProcessLifecycleOwner是基于Lifecycle对UIViewController，UIView，UIApplication的封装，大家可以基于这个思路封装项目中其他的需要感知生命周期的组件。这些封装让我们具备了数据驱动的基础，是JKLiveData能够感知生命周期变化的基础。