Texture(ASDK)的理解和使用

1
2
3
4
func tableNode(_ tableNode: ASTableNode, nodeForRowAt indexPath: IndexPath) -> ASCellNode {
    let model = Models.get(indexPath.row)
    return NewFriendsView.followCell(model: model)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func tableNode(_ tableNode: ASTableNode, nodeBlockForRowAt indexPath: IndexPath) -> ASCellNodeBlock {

    func returnCellNode() -> ASCellNode {
        let model = Models.get(indexPath.row)
        return NewFriendsView.followCell(model: model)
    }

    // this may be executed on a background thread - it is important to make sure it is thread safe
    let cellNodeBlock = { () -> ASCellNode in
        let cellNode = returnCellNode()
        return cellNode
    }

    return cellNodeBlock
}

1
2
3
4
-init – Thread safe initialization.
-layoutSpecThatFits: – Return a layout spec that defines the layout of your cell.
-didLoad – Called on the main thread. Good place to add gesture recognizers, etc.
-layout – Also called on the main thread. Layout is complete after the call to super which means you can do any extra tweaking you need to do.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// init 时候的一些参数示例

    let scoll = ASScrollNode().then { (node) in
        node.automaticallyManagesContentSize = true
        node.automaticallyManagesSubnodes = true
        node.autoresizesSubviews = true
        node.scrollableDirections = .right
//        node.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        node.backgroundColor = UIColor.white
        node.view.showsHorizontalScrollIndicator = false
    }


    // layout时候与其他控件的不同点

    scoll.layoutSpecBlock = { [weak self] _, _ in
        guard let `self` = self else { return ASLayoutSpec() }

        return self.layoutScoll()
    }

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
35
36
37
38
39
40
41
42
43
44
45
46
47
import Kingfisher

extension ASNetworkImageNode {
    static func imageNode() -> ASNetworkImageNode {
        return ASNetworkImageNode(cache: ASImageManager.shared, downloader: ASImageManager.shared)
    }
}

class ASImageManager: NSObject, ASImageDownloaderProtocol, ASImageCacheProtocol {

    static let shared = ASImageManager()
    private override init() {}

    func downloadImage(with url: URL, callbackQueue: DispatchQueue, downloadProgress: ASImageDownloaderProgress?, completion: @escaping ASImageDownloaderCompletion) -> Any? {

        ImageDownloader.default.downloadTimeout = 30.0
        var operation: RetrieveImageDownloadTask?
        operation = ImageDownloader.default.downloadImage(with: url, progressBlock: { (received, expected) in
            if downloadProgress != nil {
                callbackQueue.async(execute: {
                    let progress = expected == 0 ? 0 : received / expected
                    downloadProgress?(CGFloat(progress))
                })
            }
        }, completionHandler: { (image, error, _, data) in
            if image != nil {
                callbackQueue.async(execute: { completion(image, error, nil, nil) })
                ImageCache.default.store(image!, original: data, forKey: url.cacheKey, toDisk: true)
            } else {
                callbackQueue.async(execute: { completion(nil, nil, operation, nil) })
            }
        })
        return operation
    }

    func cancelImageDownload(forIdentifier downloadIdentifier: Any) {
        if let task = downloadIdentifier as? RetrieveImageDownloadTask {
            task.cancel()
        }
    }

    func cachedImage(with url: URL, callbackQueue: DispatchQueue, completion: @escaping ASImageCacherCompletion) {
        ImageCache.default.retrieveImage(forKey: url.cacheKey, options: nil) { (img, _) in
            callbackQueue.async { completion(img) }
        }
    }
}

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import AsyncDisplayKit

// MARK: - ASNetworkImageNode 以解决reload闪烁问题
class NetworkImageNode: ASDisplayNode {
    private var networkImageNode = ASNetworkImageNode.imageNode()
    private var imageNode = ASImageNode()

    var defaultImage: UIImage? {
        didSet {
            networkImageNode.defaultImage = defaultImage
            imageNode.image = defaultImage
        }
    }

    override var cornerRadius: CGFloat {
        didSet {
            networkImageNode.cornerRadius = cornerRadius
            imageNode.cornerRadius = cornerRadius
        }
    }

    var url: URL? {
        didSet {
            if let url = url {
                if ImageCache.default.imageCachedType(forKey: url.cacheKey).cached {
                    ImageCache.default.retrieveImage(forKey: url.cacheKey, options: nil, completionHandler: { (image, _) in
                        if let image = image {
                            self.imageNode.image = image
                        }
                    })
                } else {
                    self.networkImageNode.url = url
                }
            }
        }
    }

    override init() {
        super.init()
        addSubnode(networkImageNode)
        addSubnode(imageNode)
    }

    override func layoutSpecThatFits(_ constrainedSize: ASSizeRange) -> ASLayoutSpec {
        let url = networkImageNode.url?.absoluteString ?? ""
        return ASInsetLayoutSpec(insets: .zero, child: url.count > 0 ? networkImageNode : imageNode)
    }

    func addTarget(_ target: Any?, action: Selector, forControlEvents controlEvents: ASControlNodeEvent) {
        networkImageNode.addTarget(target, action: action, forControlEvents: controlEvents)
        imageNode.addTarget(target, action: action, forControlEvents: controlEvents)
    }
}