在 Swift 中，我如何拥有一个具有内部和外部委托的 UIScrollView 子类

Question

我正在UIScrollView子类化以添加一些功能，例如双击缩放和用于图库目的的图像属性。但是为了做图像部分，我的子类必须是它自己的委托并实现viewForZoomingInScrollView。

但是，当有人使用我的滚动视图子类时，他们可能也希望收到委托通知，以查看scrollViewDidScroll或您有什么。

在 Swift 中，我如何获得这两个？

Answer 1

下面是此模式的 Swift 版本：

尽管 forwardInvocation: 在 Swift 中被禁用，但我们仍然可以使用 forwardingTargetForSelector:

class MyScrollView: UIScrollView {
    class _DelegateProxy: NSObject, UIScrollViewDelegate {
        weak var _userDelegate: UIScrollViewDelegate?
        override func respondsToSelector(aSelector: Selector) -> Bool {
            return super.respondsToSelector(aSelector) || _userDelegate?.respondsToSelector(aSelector) == true
        }
        override func forwardingTargetForSelector(aSelector: Selector) -> AnyObject? {
            if _userDelegate?.respondsToSelector(aSelector) == true {
                return _userDelegate
            }
            else {
                return super.forwardingTargetForSelector(aSelector)
            }
        }
        func viewForZoomingInScrollView(scrollView: MyScrollView) -> UIView? {
            return scrollView.viewForZooming()
        }
        // Just a demo. You don't need this.
        func scrollViewDidScroll(scrollView: MyScrollView) {
            scrollView.didScroll()
            _userDelegate?.scrollViewDidScroll?(scrollView)
        }
    }
    private var _delegateProxy =  _DelegateProxy()
    required init(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        super.delegate = _delegateProxy
    }
    override init(frame: CGRect) {
        super.init(frame: frame)
        super.delegate = _delegateProxy
    }
    override var delegate:UIScrollViewDelegate? {
        get {
            return _delegateProxy._userDelegate
        }
        set {
            self._delegateProxy._userDelegate = newValue;
            /* It seems, we don't need this anymore.
            super.delegate = nil
            super.delegate = _delegateProxy
            */
        }
    }
    func viewForZooming() -> UIView? {
        println("self viewForZooming")
        return self.subviews.first as? UIView // whatever
    }
    func didScroll() {
        println("self didScroll")
    }
}

Answer 2

Swift 4+ 版本的 rintaro 的出色答案：

class MyScrollView: UIScrollView {
    class _DelegateProxy: NSObject, UIScrollViewDelegate {
        weak var _userDelegate: UIScrollViewDelegate?
        override func responds(to aSelector: Selector!) -> Bool {
            return super.responds(to: aSelector) || _userDelegate?.responds(to: aSelector) == true
        }
        override func forwardingTarget(for aSelector: Selector!) -> Any? {
            if _userDelegate?.responds(to: aSelector) == true {
                return _userDelegate
            }
            return super.forwardingTarget(for: aSelector)
        }
        //This function is just a demonstration, it can be replaced/removed.
        func scrollViewDidScroll(_ scrollView: UIScrollView) {
            (scrollView as? MyScrollView)?.didScroll()
            _userDelegate?.scrollViewDidScroll?(scrollView)
        }
    }
    fileprivate let _delegateProxy = _DelegateProxy()
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        super.delegate = _delegateProxy
    }
    override init(frame: CGRect) {
        super.init(frame: frame)
        super.delegate = _delegateProxy
    }
    override var delegate: UIScrollViewDelegate? {
        get {
            return _delegateProxy._userDelegate
        }
        set {
            _delegateProxy._userDelegate = newValue
        }
    }
    func didScroll() {
        print("didScroll")
    }
}

Answer 3

这是 Swift 3 中一个简单的工作 Playground 版本，它纯粹充当观察者，而不是像这里的其他答案那样仅充当拦截器。

区别在于，原始滚动视图委托应像正常一样调用其所有委托方法，而不是被另一个委托劫持。

（你可以把它复制/粘贴到操场上并运行它进行测试）

import UIKit
final class ScrollViewObserver: NSObject, UIScrollViewDelegate {
    // MARK: - Instantiation
    init(scrollView: UIScrollView) {
        super.init()
        self.scrollView = scrollView
        self.originalScrollDelegate = scrollView.delegate
        scrollView.delegate = self
    }
    deinit {
        self.remove()
    }
    // MARK: - API
    /// Removes ourselves as an observer, resetting the scroll view's original delegate
    func remove() {
        self.scrollView?.delegate = self.originalScrollDelegate
    }
    // MARK: - Private Properties
    fileprivate weak var scrollView: UIScrollView?
    fileprivate weak var originalScrollDelegate: UIScrollViewDelegate?
    // MARK: - Forwarding Delegates
    /// Note: we forward all delegate calls here since Swift does not support forwardInvocation: or NSProxy
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        // Run any custom logic or send any notifications here
        print("proxy did scroll")
        // Then, forward the call to the original delegate
        self.originalScrollDelegate?.scrollViewDidScroll?(scrollView)
    }
    func scrollViewDidZoom(_ scrollView: UIScrollView) {
        self.originalScrollDelegate?.scrollViewDidZoom?(scrollView)
    }
    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
        self.originalScrollDelegate?.scrollViewWillBeginDragging?(scrollView)
    }
    func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
        self.originalScrollDelegate?.scrollViewWillEndDragging?(scrollView, withVelocity: velocity, targetContentOffset: targetContentOffset)
    }
    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
        self.originalScrollDelegate?.scrollViewDidEndDragging?(scrollView, willDecelerate: decelerate)
    }
    func scrollViewWillBeginDecelerating(_ scrollView: UIScrollView) {
        self.originalScrollDelegate?.scrollViewWillBeginDecelerating?(scrollView)
    }
    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
        self.originalScrollDelegate?.scrollViewDidEndDecelerating?(scrollView)
    }
    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
        self.originalScrollDelegate?.scrollViewDidEndScrollingAnimation?(scrollView)
    }
    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
        return self.originalScrollDelegate?.viewForZooming?(in: scrollView)
    }
    func scrollViewWillBeginZooming(_ scrollView: UIScrollView, with view: UIView?) {
        self.originalScrollDelegate?.scrollViewWillBeginZooming?(scrollView, with: view)
    }
    func scrollViewDidEndZooming(_ scrollView: UIScrollView, with view: UIView?, atScale scale: CGFloat) {
        self.originalScrollDelegate?.scrollViewDidEndZooming?(scrollView, with: view, atScale: scale)
    }
    func scrollViewShouldScrollToTop(_ scrollView: UIScrollView) -> Bool {
        return self.originalScrollDelegate?.scrollViewShouldScrollToTop?(scrollView) == true
    }
    func scrollViewDidScrollToTop(_ scrollView: UIScrollView) {
        self.originalScrollDelegate?.scrollViewDidScrollToTop?(scrollView)
    }
}
final class TestView: UIView, UIScrollViewDelegate {
    let scrollView = UIScrollView()
    fileprivate(set) var scrollObserver: ScrollViewObserver?
    required init() {
        super.init(frame: .zero)
        self.scrollView.delegate = self
        self.scrollObserver = ScrollViewObserver(scrollView: self.scrollView)
    }
    required init?(coder aDecoder: NSCoder) { fatalError("init(coder:) has not been implemented") }
    public func scrollViewDidScroll(_ scrollView: UIScrollView) {
        print("view's original did scroll delegate method called")
    }
}
let testView = TestView()
testView.scrollView.setContentOffset(CGPoint(x: 0, y: 100), animated: true)
testView.scrollObserver?.remove()
print("removed the observer")
testView.scrollView.setContentOffset(CGPoint(x: 0, y: 200), animated: true)
testView.scrollView.setContentOffset(CGPoint(x: 0, y: 300), animated: true)

这打印

代理确实滚动

视图的原始 DID 滚动委托方法称为

删除了观察者

视图的原始 DID 滚动委托方法称为

视图的原始 DID 滚动委托方法称为

Answer 4

我不知道

有任何 100% Swift 解决方案。拿这个 ObjC 对同一问题的回答，并尝试将其移植到 Swift 上，事实证明这是不可能的，因为 NSInvocation 在 Swift 中不可用。

我们可以做的是在 ObjC 中实现建议的 MyScrollViewPrivateDelegate（不要忘记将其导入桥接头文件中）和 Swift 中的滚动视图子类，如下所示：

我的滚动视图.swift

import UIKit
class MyScrollView: UIScrollView {
    private let myDelegate = MyScrollViewPrivateDelegate()
    required init(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        super.delegate = myDelegate
    }
    override init(frame: CGRect) {
        super.init(frame: frame)
        super.delegate = myDelegate
    }
    override var delegate: UIScrollViewDelegate? {
        set {
            myDelegate.userDelegate = newValue
            super.delegate = nil
            super.delegate = myDelegate
        }
        get {
            return myDelegate.userDelegate
        }
    }
    func viewForZooming() -> UIView {
        return UIView()// return whatever you want here...
    }
}

MyScrollViewPrivateDelegate.h

#import <UIKit/UIKit.h>
@interface MyScrollViewPrivateDelegate : NSObject <UIScrollViewDelegate>
@property (weak, nonatomic) id<UIScrollViewDelegate> userDelegate;
@end

MyScrollViewPrivateDelegate.m

#import "MyScrollViewPrivateDelegate.h"
#import "YOUR_MODULE-Swift.h"
@implementation MyScrollViewPrivateDelegate
- (UIView *)viewForZoomingInScrollView:(UIScrollView *)scrollView
{
    // you could check if the user delegate responds to viewForZoomingInScrollView and call it instead...
    return [(MyScrollView *)scrollView viewForZooming];
}
- (BOOL)respondsToSelector:(SEL)selector 
{
    return [_userDelegate respondsToSelector:selector] || [super respondsToSelector:selector];
}
- (void)forwardInvocation:(NSInvocation *)invocation 
{
    [invocation invokeWithTarget:_userDelegate];
}
@end