一艘小船

public class MemoryChecker {
    public static func verifyDealloc(_ object: AnyObject?) {
        #if DEBUG
            DispatchQueue.main.asyncAfter(deadline: .now() + 5) { [weak object] in
                if let object = object {
                    fatalError("Class Not Deallocated: \(String(describing: object.classForCoder ?? object)))")
                }
            }
        #endif
    }
}

class NavigationController: UINavigationController {

    deinit {
        viewControllers.forEach{ MemoryChecker.verifyDealloc($0) }
    }
    
    override func popViewController(animated: Bool) -> UIViewController? {
        let viewController = super.popViewController(animated: animated)
        MemoryChecker.verifyDealloc(viewController)
        return viewController
    }
}

class WeakBox<A: AnyObject> {
    weak var unbox: A?

    init(_ value: A) {
        unbox = value
    }
}

class TableView: UITableView {
    private var allCells: [WeakBox<UITableViewCell>] = []

    private func appendIfNotPresent(_ cell: UITableViewCell) {
        if allCells.first(where: { $0.unbox === cell }) == nil {
            allCells.append(WeakBox(cell))
        }
    }

    override func dequeueReusableCell(withIdentifier identifier: String, for indexPath: IndexPath) -> UITableViewCell {
        let cell = super.dequeueReusableCell(withIdentifier: identifier, for: indexPath)
        appendIfNotPresent(cell)
        return cell
    }

    deinit {
        allCells.forEach { MemoryChecker.verifyDealloc($0.unbox) }
    }
}

- (BOOL)willDealloc {
    NSString *className = NSStringFromClass([self class]);
    if ([[NSObject classNamesWhitelist] containsObject:className])
        return NO;
    
    NSNumber *senderPtr = objc_getAssociatedObject([UIApplication sharedApplication], kLatestSenderKey);
    if ([senderPtr isEqualToNumber:@((uintptr_t)self)])
        return NO;
    
    __weak id weakSelf = self;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        __strong id strongSelf = weakSelf;
        [strongSelf assertNotDealloc];
    });
    
    return YES;
}

 private func setupAlamofireCache() {
    let imageCache = AutoPurgingImageCache(
        memoryCapacity: 30_000_000,
        preferredMemoryUsageAfterPurge: 15_000_000
    )
	
    UIImageView.af_sharedImageDownloader = AlamofireImage.ImageDownloader(maximumActiveDownloads: 12,
	                                                                          imageCache: imageCache)
}

public extension UIGraphicsRenderer {
    
    static func renderImagesAt(url: URL, size: CGSize, scale: CGFloat = 1) throws -> UIImage {
        let renderer = UIGraphicsImageRenderer(size: size)
	
        let options: [NSString: Any] = [
            kCGImageSourceThumbnailMaxPixelSize: max(size.width * scale, size.height * scale),
            kCGImageSourceCreateThumbnailFromImageAlways: true
        ]
	
        let thumbnail = try {
            guard let imageSource = CGImageSourceCreateWithURL(url as CFURL, nil) else { throw RenderingError.unableToCreateImageSource }
            guard let scaledImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, options as CFDictionary) else {  throw RenderingError.unableToCreateThumbnail }
            return scaledImage
        }()
	
        let rect = CGRect(x: 0,
                          y: -size.height,
                          width: size.width,
                          height: size.height)
	
        let resizedImage = renderer.image { ctx in
            
            let context = ctx.cgContext
            context.scaleBy(x: 1, y: -1)
            context.draw(thumbnail, in: rect)
        }
	
        return resizedImage
    }
}

let size = CGSize(width: 100, height: 100)
        
let iv = UIImageView(frame: .init(x: 100, y: 400, width: 100, height: 100))
view.addSubview(iv)
    
let imagePath = Bundle.main.path(forResource: "image", ofType: "jpg")!
let imageUrl = URL(fileURLWithPath: imagePath)
    
//iv.image = UIImage(contentsOfFile: imagePath)
    
if let image = try? UIGraphicsRenderer.renderImagesAt(url: imageUrl, size: size, scale: 4) {
    iv.image = image
}

class TestLeak {
    deinit {
        print("\(self) deinit")
    }
    var fun: (() -> Void)? = nil
    
    func setFun() {
        fun = fun2
    }
    
    func setFun1() {
        fun = TestLeak.fun3
    }
    
    func fun2() {
        print("fun2")
    }
    
    class func fun3() {
        print("fun3")
    }
}

let beginObserver = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, CFRunLoopActivity.allActivities.rawValue, true, .min) { observer, activity in
    switch activity {
    case .entry:
        print("entry")
    case .beforeSources:
        print("source")
    case .beforeTimers:
        print("timer")
    case .afterWaiting:
        gettimeofday(&self.tvStart, nil)
        print("awake")
    case .beforeWaiting:
        print("sleep")
    default:
        print("def")
    }
    
}
    
let endObserver = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, CFRunLoopActivity.allActivities.rawValue, true, .max) { observer, activity in
    switch activity {
    case .entry:
        print("2 entry")
    case .beforeSources:
        print("2 source")
    case .beforeTimers:
        print("2 timer")
    case .afterWaiting:
        print("2 awake")
    case .beforeWaiting:
        
        // check
        var tvCur = timeval()
        gettimeofday(&tvCur, nil)
        let duration = self.getDuration(tvStart: self.tvStart, tvEnd: tvCur)
        print("2 sleep", duration)
    default:
        print("2 def")
    }
}
    
CFRunLoopAddObserver(CFRunLoopGetCurrent(), beginObserver, .commonModes)
CFRunLoopAddObserver(CFRunLoopGetCurrent(), endObserver, .commonModes)

awake
2 awake
timer
2 timer
source
2 source
sleep
2 sleep 6739
awake
2 awake
timer
2 timer
source
2 source
sleep
2 sleep 189
awake
2 awake
timer
2 timer
source
2 source
sleep
2 sleep 2057
awake
2 awake
timer
2 timer
source
2 source
sleep
2 sleep 169

class DetectorMainThread {
    static let shared = DetectorMainThread()
    
    private var isRunning = false
    
    @Protected
    private var isMainRunloopBegain = false
 
    private var tvStart: timeval = timeval()
    
    private let unfairLock: os_unfair_lock_t
    private let queue = DispatchQueue(label: "DetectorMainThread_Queue", attributes: .concurrent)
    private let semaphore = DispatchSemaphore(value: 0)

    private init() {
        unfairLock = .allocate(capacity: 1)
        unfairLock.initialize(to: os_unfair_lock())
        
        registMainRunloopObserver()
    }

    func start() {
        os_unfair_lock_lock(unfairLock)

        if isRunning {
            os_unfair_lock_unlock(unfairLock)
            return
        }
        
        isRunning = true
        os_unfair_lock_unlock(unfairLock)
        
        queue.async {
          
            while self.getIsRunning() {
                self.queue.asyncAfter(deadline: .now() + 1) {
                    self.semaphore.signal()
                }
                
                self.semaphore.wait()
                
                self.check()
            }
        }
    }
    
    
    func stop() {
        os_unfair_lock_lock(unfairLock)
        isRunning = false
        os_unfair_lock_unlock(unfairLock)
    }
    
    func getIsRunning() -> Bool {
        
        os_unfair_lock_lock(self.unfairLock)
        var isRunning = self.isRunning
        os_unfair_lock_unlock(self.unfairLock)

        return isRunning
    }
    
    
    private func check() {
        $isMainRunloopBegain.read {
            if $0 {
                var tvCur = timeval()
                gettimeofday(&tvCur, nil)
                let duration = getDuration(tvStart: tvStart, tvEnd: tvCur)
                
                print("ANR: \(Float(duration) / 1000)ms")
            }
        }
    }
    

    
    private func registMainRunloopObserver() {
        let beginObserver = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, CFRunLoopActivity.afterWaiting.rawValue, true, .min) { observer, activity in
            gettimeofday(&self.tvStart, nil)
            self.$isMainRunloopBegain.write { $0 = true }
        }

        let endObserver = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, CFRunLoopActivity.beforeWaiting.rawValue, true, .max) { observer, activity in
            self.$isMainRunloopBegain.write { $0 = false }
        }

        CFRunLoopAddObserver(CFRunLoopGetMain(), beginObserver, .commonModes)
        CFRunLoopAddObserver(CFRunLoopGetMain(), endObserver, .commonModes)
    }
}

protocol API {
    func request()
}

protocol API {
    func request(config: ApiConfigProtocol, timeoutInterval: TimeInterval)
}

protocol API {
    func request<T: APIMappable>(
        config: ApiConfigProtocol,
        timeoutInterval: TimeInterval) -> Response<T>
}

protocol APIMappable: BaseMappable {
    init?(json: Any?)
}

extension APIMappable {
    public init?(map: Map) { self.init(json: nil) }
    
    init?(json: Any?) {
        guard let JSON = json as? [String: Any],
           let obj: Self = Mapper().map(JSON: JSON) else {
            return nil
        }
        
        self = obj
    }
}

extension Array: APIMappable, BaseMappable where Element: BaseMappable {
    public mutating func mapping(map: ObjectMapper.Map) {}
    
    init?(json: Any?) {
        if let JSONArray = json as? [[String: Any]] {
            let obj: [Element] = Mapper(context: nil).mapArray(JSONArray: JSONArray)
            self = obj
        } else {
            return nil
        }
    }
}

protocol ApiConfigProtocol {
    /// 域名
    var domain: String {get}
    /// 路径
    var path: String {get}
    /// 请求方法
    var method: HTTPMethod {get}
    /// 请求头
    var header: HTTPHeaders { get }
    /// 请求参数
    var parameters: [String: Any]? { get }
    /// 参数编码
    var encoder: ParameterEncoding {get}
}

extension ApiConfigProtocol {
    var domain: String { "https://xxxx.com" }
    var header: HTTPHeaders { defaultHeader() }

    
    func defaultHeader() -> HTTPHeaders {
        var dic = [String: String]()
        dic["token"] = "xxxx"
        return HTTPHeaders.init(dic)
    }
}

enum APISystemConfig: ApiConfigProtocol {
    case sysTime
    case sysVersion
    
    var path: String {
        switch self {
        case .sysTime: return "/sysTime"
        case .sysVersion: return "/sysVersion"
        }
    }
    
    var header: HTTPHeaders {
        var defaultHeader = defaultHeader()
        
        switch self {
        case .sysTime:  return defaultHeader
        case .sysVersion:
            defaultHeader.add(name: "platform", value: "ios")
            return defaultHeader
        }
    }
    
    var method: HTTPMethod {
        switch self {
        case .sysTime: return .get
        case .sysVersion: return .post
        }
    }
    
    var parameters: [String : Any]? {
        switch self {
        case .sysTime: return [:]
        case .sysVersion: return ["appVersion": "1.0.0"]
        }
    }
    
    
    var encoder: ParameterEncoding {
        switch self {
        case .sysTime, .sysVersion: return JSONEncoding.default
        }
    }
}

class Response<T: APIMappable> {
    init() {}
    weak var request: DataRequest?
    func cancel() {
        request?.cancel()
    }
    
    typealias successBlock = (T) -> Void
    typealias errorBlock = (APIError) -> Void
    
    
    private var successBlocks = [successBlock?]()
    private var errorBlocks = [errorBlock?]()

 
    fileprivate func postSuccess(_ model: T) {
        successBlocks.forEach {$0?(model)}
    }
    
    fileprivate func postError(_ error: APIError) {
        errorBlocks.forEach {$0?(error)}
    }
  
    
    
    @discardableResult
    func success(_ completionHandler: successBlock?) -> Self {
        modelBlocks.append(completionHandler)
        return self
    }
    
  
    @discardableResult
    func error(_ completionHandler: errorBlock?) -> Self {
        errorBlocks.append(completionHandler)
        return self
    }
}

{
    "code": 200,
    "message": "no message",
    "data": {
        "time": 2942798372937
    }
    
}

class ResponseModel: APIMappable {
    var code = 0
    var message = ""
    var data: Any? = nil
    
    
    func mapping(map: ObjectMapper.Map) {
        code <- map["code"]
        message <- map["message"]
        data <- map["data"]
    }
}

class SysTimeModel: APIMappable {
    var time: TimeInterval = 0
    func mapping(map: ObjectMapper.Map) {
        time <- map["time"]
    }
}

extension API {
    func request<T: APIMappable>(
        config: ApiConfigProtocol,
        timeoutInterval: TimeInterval = 20) -> Response<T> {
            let result = Response<T>()
            
            let request = AF.request(config.domain + config.path,
                                     method: config.method,
                                     parameters: config.parameters,
                                     encoding: config.encoder,
                                     headers: config.header
            ) {$0.timeoutInterval = timeoutInterval}
            
            
            request.responseData { res in
                switch res.result {
                case .success(let data):
                    if let JSON = try? JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions.allowFragments),
                       let model = ResponseModel(json: JSON) {
                        
                        switch model.code {
                        case 200:
                            if let model = T.init(json: JSON) {
                                result.postSuccess(model)
                            } else {
                                result.postError(APIError(message: "解析错误 \(model.message)"))
                            }
                        case 401:
                            print("token失效")
                            // loginOut()
                        default:
                            result.postError(APIError(message: "未知错误 \(model.message)"))
                        }
                        
                    } else {
                        result.postError(APIError(message: "JSON解析错误"))
                    }
                    
                case .failure(let error):
                    result.postError(APIError(message: error.localizedDescription))
                }
            }
            
            result.request = request
            
            return result
        }
}

protocol SystemAPI: API {}
extension SystemAPI {
    func getSysTime() -> Response<ResponseModel> {
        return request(config: APISystemConfig.sysTime)
    }
    
    func getSysVersion() -> Response<[ResponseModel]> {
        return request(config: APISystemConfig.sysVersion)
    }
}

extension ViewController: SystemAPI {
    func getData() {
        
        getSysTime()
            .success { model in
                print("model", model.time)
            }
            .success { model in
                print("this model is", model)
            }
            .error { err in
                print("err", err.message)
            }
        
        
        let getSysVersionTask = getSysVersion()
            
            
        getSysVersionTask.success { list in
            list.forEach {print("list model _", $0.time)}
        }
        
        getSysVersionTask.error { err in
            
        }
        
        getSysVersionTask.cancel()
    }
}

class Person {
    var age = 0
    var name = ""
    
    func sayName() {
        print("my age is \(name)")
    }
    
    func eat() {
        print("eat food.")
    }
}


class Student: Person {
    override func eat() {
        print("eat Person meal")
    }
}

class Teacher: Person {
    var salary = 0.0
    
    override func eat() {
        print("eat Teacher meal")
    }
    
    func getPaid() {
        print("this month get paid: \(salary)")
    }
}

class Cook: Person {
    override func eat() {
        print("Cook eat")
    }
    func Salary() { }
}

class Workers: Person {
    var salary = 0.0
    func getPaid() {
        print("this month get paid: \(salary)")
    }
}

class Teacher: Workers {
    override func eat() {
        print("eat Teacher meal")
    }
}

class Cook: Workers {
    override func eat() {
        print("Cook eat")
    }
}

protocol PersonProtocol {
    var age: Int {set get}
    var name: String {set get}
    
    func sayName()
    func eat()
}

extension PersonProtocol {
    func sayName() {
        print("my age is \(name)")
    }
    
    func eat() {
        print("eat food.")
    }
}

protocol WorkersProtocol: PersonProtocol {
    var salary: Float { set get }
    func getPaid()
    
}
extension WorkersProtocol {
    func getPaid() {
        print("this month get paid: \(salary)")
    }
}

class Student: PersonProtocol {
    var age: Int = 0
    var name: String = ""
    
    func eat() {
        print("eat Person meal")
    }
}


class Teacher: WorkersProtocol {
    var age: Int = 0
    var name: String = ""
    var salary: Float = 0.0
    
    func eat() {
        print("eat Teacher meal")
    }
}

class Cook: WorkersProtocol {
    var age: Int = 0
    var name: String = ""
    var salary: Float = 0.0
    
    func eat() {
        print("Cook eat")
    }
}