iOS 消息调用属于基本知识，苹果官方有一个详细的介绍图：

1 - (BOOL)resolveInstanceMethod:(SEL)sel ; 
2 - (id)forwardingTargetForSelector:(SEL)aSelector ;

1 + (BOOL)resolveClassMethod:(SEL)sel ; 
2 - (void)doesNotRecognizeSelector:(SEL)aSelector ;

if (@available(iOS 13.0, *)) {
   self.overrideUserInterfaceStyle =  UIUserInterfaceStyleDark;//UIUserInterfaceStyleLight
} else {
    // Fallback on earlier versions
}

注意当我们在window上设置 overrideUserInterfaceStyle的时候，就会影响 window下所有的controller,view，包括后续推出的 controller。

UIStatusBarManager *statusBarManager = [UIApplication sharedApplication].keyWindow.windowScene.statusBarManager;
UIView *statusBar;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wundeclared-selector"
if([statusBarManager respondsToSelector:@selector(createLocalStatusBar)]) {
            
    UIView *localStatusBar= [statusBarManager performSelector:@selector(createLocalStatusBar)];
    if ([localStatusBar respondsToSelector:@selector(statusBar)]) {
                
        statusBar = [localStatusBar performSelector:@selector(statusBar)];
    }    
}

if(@available(iOS 13.0, *)) {

    //上面获取statusBar代码        
} else {
    
    UIView *statusBar = [[UIApplication sharedApplication] 
    valueForKey:@"statusBar"];

}

//在ios13使用会引发崩溃
[self.textField setValue:self.placeholderColor 
forKeyPath:@"_placeholderLabel.textColor"];

'Access to UITextField's _placeholderLabel ivar is prohibited. 
This is an application bug'

NSMutableAttributedString *placeholderString = [[NSMutableAttributedString alloc] initWithString:placeholder 
attributes:@{NSForegroundColorAttributeName : self.placeholderColor}];
_textField.attributedPlaceholder = placeholderString;

erminating app due to uncaught exception'NSInternalInconsistencyException', reason: 'Missing or detached view for search bar layout'

for (UIView *view in _searchBar.subviews.lastObject.subviews) {
   if ([view isKindOfClass:NSClassFromString(@"UISearchBarBackground")]) {
        view.layer.contents = nil;
        break;
    }
 }

UITextField *searchFiled = [self valueForKey:@"_searchField"];

@property (nonatomic, readonly) UISearchTextField *searchTextField;

UIKIT_CLASS_AVAILABLE_IOS_ONLY(13.0)
@interface UISearchTextField : UITextField
///功能省略
@end

UITextField *searchField;
 if(@available(iOS 13.0, *)) {
    //UISearchBar的self.searchTextField属性是readonly，不能直接用
    searchField =  self.searchTextField; 
 } else {
    searchField = [self valueForKey:@"_searchField"];
 }

- (UIModalPresentationStyle)modalPresentationStyle {
    return UIModalPresentationFullScreen;
}

'MPMoviePlayerController is no longer available. Use AVPlayerViewController in AVKit.'

UIWindow* window = nil;
if (@available(iOS 13.0, *)) {
    for (UIWindowScene* windowScene in [UIApplication sharedApplication].connectedScenes) {
        if (windowScene.activationState == UISceneActivationStateForegroundActive) {
            window = windowScene.windows.firstObject;
            break;
        }
    }
}else{
    window = [UIApplication sharedApplication].keyWindow;
}

if ( @available(iOS 13.0, *)) {
    self.segmentedControl.selectedSegmentTintColor = [UIColor yellowcolor];
} else {
    self.segmentedControl.tintColor = [UIColor yellowcolor];
}

前言

小编最近在项目中遇到了一个问题，除刘海屏以外的iOS设备可以正常的搜索到硬件设备，但是刘海屏就不行。因此，小编花了一点时间研究了一下iOS设备获取当前设备的网络状态。

实现

因为iOS的系统是封闭的，所以是没有直接的APi去获取当前的网络状态。但是道高一尺，魔高一尺。开发者总会有办法获取自己想要的东西。

1.网络状态获取

获取当前的网络类型

获取当前的网络类型是通过获取状态栏，然后遍历状态栏的视图完成的。

先导入头文件，如下：

#import "AppDelegate.h"

实现方法如下：

+ (NSString *)getNetworkType
{
    UIApplication *app = [UIApplication sharedApplication];
    id statusBar = nil;
//    判断是否是iOS 13
    NSString *network = @"";
    if (@available(iOS 13.0, *)) {
        UIStatusBarManager *statusBarManager = [UIApplication sharedApplication].keyWindow.windowScene.statusBarManager;
        
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wundeclared-selector"
        if ([statusBarManager respondsToSelector:@selector(createLocalStatusBar)]) {
            UIView *localStatusBar = [statusBarManager performSelector:@selector(createLocalStatusBar)];
            if ([localStatusBar respondsToSelector:@selector(statusBar)]) {
                statusBar = [localStatusBar performSelector:@selector(statusBar)];
            }
        }
#pragma clang diagnostic pop
        
        if (statusBar) {
//            UIStatusBarDataCellularEntry
            id currentData = [[statusBar valueForKeyPath:@"_statusBar"] valueForKeyPath:@"currentData"];
            id _wifiEntry = [currentData valueForKeyPath:@"wifiEntry"];
            id _cellularEntry = [currentData valueForKeyPath:@"cellularEntry"];
            if (_wifiEntry && [[_wifiEntry valueForKeyPath:@"isEnabled"] boolValue]) {
//                If wifiEntry is enabled, is WiFi.
                network = @"WIFI";
            } else if (_cellularEntry && [[_cellularEntry valueForKeyPath:@"isEnabled"] boolValue]) {
                NSNumber *type = [_cellularEntry valueForKeyPath:@"type"];
                if (type) {
                    switch (type.integerValue) {
                        case 0:
//                            无sim卡
                            network = @"NONE";
                            break;
                        case 1:
                            network = @"1G";
                            break;
                        case 4:
                            network = @"3G";
                            break;
                        case 5:
                            network = @"4G";
                            break;
                        default:
//                            默认WWAN类型
                            network = @"WWAN";
                            break;
                            }
                        }
                    }
                }
    }else {
        statusBar = [app valueForKeyPath:@"statusBar"];
        
        if ([[[self alloc]init]isLiuHaiScreen]) {
//            刘海屏
                id statusBarView = [statusBar valueForKeyPath:@"statusBar"];
                UIView *foregroundView = [statusBarView valueForKeyPath:@"foregroundView"];
                NSArray *subviews = [[foregroundView subviews][2] subviews];
                
                if (subviews.count == 0) {
//                    iOS 12
                    id currentData = [statusBarView valueForKeyPath:@"currentData"];
                    id wifiEntry = [currentData valueForKey:@"wifiEntry"];
                    if ([[wifiEntry valueForKey:@"_enabled"] boolValue]) {
                        network = @"WIFI";
                    }else {
//                    卡1:
                        id cellularEntry = [currentData valueForKey:@"cellularEntry"];
//                    卡2:
                        id secondaryCellularEntry = [currentData valueForKey:@"secondaryCellularEntry"];

                        if (([[cellularEntry valueForKey:@"_enabled"] boolValue]|[[secondaryCellularEntry valueForKey:@"_enabled"] boolValue]) == NO) {
//                            无卡情况
                            network = @"NONE";
                        }else {
//                            判断卡1还是卡2
                            BOOL isCardOne = [[cellularEntry valueForKey:@"_enabled"] boolValue];
                            int networkType = isCardOne ? [[cellularEntry valueForKey:@"type"] intValue] : [[secondaryCellularEntry valueForKey:@"type"] intValue];
                            switch (networkType) {
                                    case 0://无服务
                                    network = [NSString stringWithFormat:@"%@-%@", isCardOne ? @"Card 1" : @"Card 2", @"NONE"];
                                    break;
                                    case 3:
                                    network = [NSString stringWithFormat:@"%@-%@", isCardOne ? @"Card 1" : @"Card 2", @"2G/E"];
                                    break;
                                    case 4:
                                    network = [NSString stringWithFormat:@"%@-%@", isCardOne ? @"Card 1" : @"Card 2", @"3G"];
                                    break;
                                    case 5:
                                    network = [NSString stringWithFormat:@"%@-%@", isCardOne ? @"Card 1" : @"Card 2", @"4G"];
                                    break;
                                default:
                                    break;
                            }
                            
                        }
                    }
                
                }else {
                    
                    for (id subview in subviews) {
                        if ([subview isKindOfClass:NSClassFromString(@"_UIStatusBarWifiSignalView")]) {
                            network = @"WIFI";
                        }else if ([subview isKindOfClass:NSClassFromString(@"_UIStatusBarStringView")]) {
                            network = [subview valueForKeyPath:@"originalText"];
                        }
                    }
                }
                
            }else {
//                非刘海屏
                UIView *foregroundView = [statusBar valueForKeyPath:@"foregroundView"];
                NSArray *subviews = [foregroundView subviews];
                
                for (id subview in subviews) {
                    if ([subview isKindOfClass:NSClassFromString(@"UIStatusBarDataNetworkItemView")]) {
                        int networkType = [[subview valueForKeyPath:@"dataNetworkType"] intValue];
                        switch (networkType) {
                            case 0:
                                network = @"NONE";
                                break;
                            case 1:
                                network = @"2G";
                                break;
                            case 2:
                                network = @"3G";
                                break;
                            case 3:
                                network = @"4G";
                                break;
                            case 5:
                                network = @"WIFI";
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
    }

    if ([network isEqualToString:@""]) {
        network = @"NO DISPLAY";
    }
    return network;
}

获取当前的Wifi信息

获取当前的Wifi信息需要借助系统的SystemConfiguration这个库。
先导入头文件，如下：

#import <SystemConfiguration/CaptiveNetwork.h>

实现方法如下：

#pragma mark 获取Wifi信息
+ (id)fetchSSIDInfo
{
    NSArray *ifs = (__bridge_transfer id)CNCopySupportedInterfaces();
    id info = nil;
    for (NSString *ifnam in ifs) {
        info = (__bridge_transfer id)CNCopyCurrentNetworkInfo((__bridge CFStringRef)ifnam);
        
        if (info && [info count]) {
            break;
        }
    }
    return info;
}
#pragma mark 获取WIFI名字
+ (NSString *)getWifiSSID
{
    return (NSString *)[self fetchSSIDInfo][@"SSID"];
}
#pragma mark 获取WIFI的MAC地址
+ (NSString *)getWifiBSSID
{
    return (NSString *)[self fetchSSIDInfo][@"BSSID"];
}

获取当前的Wifi信号强度

获取信号强度与获取网络状态有点类似，通过遍历状态栏，从而获取WIFI图标的信号强度。在获取前需注意当前状态是否为WIFI。如下：

+ (int)getWifiSignalStrength{
    
    int signalStrength = 0;
//    判断类型是否为WIFI
    if ([[self getNetworkType]isEqualToString:@"WIFI"]) {
//        判断是否为iOS 13
        if (@available(iOS 13.0, *)) {
            UIStatusBarManager *statusBarManager = [UIApplication sharedApplication].keyWindow.windowScene.statusBarManager;
             
            id statusBar = nil;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wundeclared-selector"
            if ([statusBarManager respondsToSelector:@selector(createLocalStatusBar)]) {
                UIView *localStatusBar = [statusBarManager performSelector:@selector(createLocalStatusBar)];
                if ([localStatusBar respondsToSelector:@selector(statusBar)]) {
                    statusBar = [localStatusBar performSelector:@selector(statusBar)];
                }
            }
#pragma clang diagnostic pop
            if (statusBar) {
                id currentData = [[statusBar valueForKeyPath:@"_statusBar"] valueForKeyPath:@"currentData"];
                id wifiEntry = [currentData valueForKeyPath:@"wifiEntry"];
                if ([wifiEntry isKindOfClass:NSClassFromString(@"_UIStatusBarDataIntegerEntry")]) {
//                    层级：_UIStatusBarDataNetworkEntry、_UIStatusBarDataIntegerEntry、_UIStatusBarDataEntry
                    
                    signalStrength = [[wifiEntry valueForKey:@"displayValue"] intValue];
                }
            }
        }else {
            UIApplication *app = [UIApplication sharedApplication];
            id statusBar = [app valueForKey:@"statusBar"];
            if ([[[self alloc]init]isLiuHaiScreen]) {
//                刘海屏
                id statusBarView = [statusBar valueForKeyPath:@"statusBar"];
                UIView *foregroundView = [statusBarView valueForKeyPath:@"foregroundView"];
                NSArray *subviews = [[foregroundView subviews][2] subviews];
                       
                if (subviews.count == 0) {
//                    iOS 12
                    id currentData = [statusBarView valueForKeyPath:@"currentData"];
                    id wifiEntry = [currentData valueForKey:@"wifiEntry"];
                    signalStrength = [[wifiEntry valueForKey:@"displayValue"] intValue];
//                    dBm
//                    int rawValue = [[wifiEntry valueForKey:@"rawValue"] intValue];
                }else {
                    for (id subview in subviews) {
                        if ([subview isKindOfClass:NSClassFromString(@"_UIStatusBarWifiSignalView")]) {
                            signalStrength = [[subview valueForKey:@"_numberOfActiveBars"] intValue];
                        }
                    }
                }
            }else {
//                非刘海屏
                UIView *foregroundView = [statusBar valueForKey:@"foregroundView"];
                     
                NSArray *subviews = [foregroundView subviews];
                NSString *dataNetworkItemView = nil;
                       
                for (id subview in subviews) {
                    if([subview isKindOfClass:[NSClassFromString(@"UIStatusBarDataNetworkItemView") class]]) {
                        dataNetworkItemView = subview;
                        break;
                    }
                }
                       
                signalStrength = [[dataNetworkItemView valueForKey:@"_wifiStrengthBars"] intValue];
                        
                return signalStrength;
            }
        }
    }
    return signalStrength;
}

2.Reachability的使用

下载开源类Reachability，然后根据文档使用即可（该类把移动网络统称为WWAN）：+ (NSString *)getNetworkTypeByReachability

{
    NSString *network = @"";
    switch ([[Reachability reachabilityForInternetConnection]currentReachabilityStatus]) {
        case NotReachable:
            network = @"NONE";
            break;
        case ReachableViaWiFi:
            network = @"WIFI";
            break;
        case ReachableViaWWAN:
            network = @"WWAN";
            break;
        default:
            break;
    }
    if ([network isEqualToString:@""]) {
        network = @"NO DISPLAY";
    }
    return network;
}

上次发布了这篇文章之后，有人问我，怎么才能获取设备的IP地址呢？在这里，小编附上获取iP地址的方法。
先导入头文件，如下：

#import <ifaddrs.h>
#import <arpa/inet.h>

实现方法，如下：

#pragma mark 获取设备IP地址
+ (NSString *)getIPAddress
{
    NSString *address = @"error";
    struct ifaddrs *interfaces = NULL;
    struct ifaddrs *temp_addr = NULL;
    int success = 0;
    // 检索当前接口,在成功时,返回0
    success = getifaddrs(&interfaces);
    if (success == 0) {
        // 循环链表的接口
        temp_addr = interfaces;
        while(temp_addr != NULL) {
//                开热点时本机的IP地址
                if ([[NSString stringWithUTF8String:temp_addr->ifa_name] isEqualToString:@"bridge100"]
                    ) {
                    address = [NSString stringWithUTF8String:inet_ntoa(((struct sockaddr_in *)temp_addr->ifa_addr)->sin_addr)];
                }
            if(temp_addr->ifa_addr->sa_family == AF_INET) {
                // 检查接口是否en0 wifi连接在iPhone上
                if([[NSString stringWithUTF8String:temp_addr->ifa_name] isEqualToString:@"en0"]) {
                    // 得到NSString从C字符串
                    address = [NSString stringWithUTF8String:inet_ntoa(((struct sockaddr_in *)temp_addr->ifa_addr)->sin_addr)];
                }
            }
            temp_addr = temp_addr->ifa_next;
        }
    }
    // 释放内存
    freeifaddrs(interfaces);
    return address;
}

iOS 开发小记

8.10日遇见问题新接手的苹果账号无法真机运行，查询一番以为是证书的问题。登录到苹果的官网发现手机有个7天无效的问题。

最终解决的方式是换了个手机 添加到真机运行中就可以了

但是无法运行的手机，估计是需要等到七天之后查看结果。七天之后应该是有所变化

产生这个问题的原因：有大佬解答是因为 苹果账号被封过。导致手机的UUID被标记。换到其他的苹果账号会有这种情况的发生

（我遇到过的是被封过开发者账号的，一个开发者账号被封，里面的测试机也会被苹果标记，再换其他的开发者账号，就可以关联到一起了）

前言

    这一年是2040年，我们最新的 MacBook M30X 处理器可以感知到瞬间编译大型 Swift 项目，听起来很神奇，对吧？除此之外，编译代码库只是我们迭代周期的一部分。包括：
    1、重新启动它（或将其部署到设备）
    2、导航到您在应用程序中的先前位置
    3、重新生成您需要的数据。
    如果您只需要做一次的话，听起来还不错。但是如果您和我一样，在特别的一天中，对代码库进行 200 - 500 次迭代，该怎么办呢？它增加了。
    有一种更好的方法，被其他平台所接受，并且可以在 Swift/iOS 生态系统中实现。我已经用了十多年了。
    从今天开始，您想每周节省多达 10 小时的工作时间吗？

热重载

    热重载是关于摆脱编译整个应用程序并尽可能避免部署/重新启动周期，同时允许您编辑正在运行的应用程序代码并且能立即看到更改。
    这种流程改进可以每天为您节省数小时的开发时间。我跟踪我的工作一个多月，对我来说，每天节省了 1-2 小时。
    坦白地说，如果每周节省10个小时的开发时间都不能说服您去尝试，那么我认为任何方法都不能说服你。

其他平台在做什么？

    如果您只使用 Apple 平台，您会惊讶地发现有好多平台几十年前已经采用了热重载。无论您是编写 Node 还是任何其他 JS 框架，都有一个使用热重载的设置。Go 也提供了热重载（本博客使用了该特性）
    另一个例子是谷歌的 Flutter 架构，从一开始就设计用于热重载。如果您与从事 Flutter 工作的工程师交谈，你会发现他们最喜欢 Flutter 开发者体验的一点就是能够实时编写他们的应用程序。当我为《纽约时报》写了一个拼字游戏时，我很喜欢它。
    微软最近推出了 Visual Studio 2022，并为 .NET 和 标准 C++ 应用程序提供热重载，在过去的十年中，微软在开发工具和经验方面一直在大杀四方，所以这并不令人惊讶。

苹果生态系统怎么样？

    早在 2014 年推出时，很多人都对 Swift Playgrounds 感到敬畏，因为它们允许我们快速迭代并查看代码的结果，但它们并不能很好地工作，因为它存在崩溃、挂起等问题。不能支持整个iPad环境。
    在它们发布后不久，我启动了一个名为 Objective-C Playgrounds 的开源项目，它比官方 Playgrounds 运行得更快、更可靠。我的想法是设计一个架构/工作流程，利用我已经使用了几年的 DyCI 代码注入工具，该工具已经由 Paul 制作。
    自从 Swift Playgrounds 存在以来，已经过去了八年，而且它们变得更好了，但它们可靠吗？人们是否在使用它们来推动开发？

    SwiftUI 出现了，它是一项了不起的技术（尽管仍然存在错误），它引入了与 Playgrounds 非常相似的 Swift Previews 的想法，它们有什么好处吗？
    类似的故事，当它工作的时候是很好的，但是在更大的项目中，它的工作是不可靠的，而且往往中断的次数比它们工作的次数多。如果你有任何错误，他们不会为你提供调试代码的能力，因此，采用的情况有限。

我们需要等待 Apple 吗？

    如果你关注我一段时间，你就已经知道答案了，绝对不要。毕竟，我的职业生涯是构建普通 Apple 解决方案无法解决的问题：从像 Sourcery 这样的语言扩展、像 Sourcery Pro 这样的 Xcode 改进，再到 LifetimeTracker 以及许多其他开源工具。
    我们可以利用我最初在 2014 Playgrounds 中使用的相同方法。我已经使用它十多年了，并且在数十个 Swift 项目中使用它并取得了巨大的成功！
    许多年前，我从使用 DyCI 切换到 InjectionForXcode，通过利用 LLVM 互操作而不是任何 swizzling ，它的效果更好。它是一个完全免费的开源工具，您可以在菜单栏中运行，它是由多产的工程师 John Holdsworth 创建的。你应该看看他的书 Swift Secrets。
    我意识到 Playgrounds 的方法可能过于笨重，所以今天，我开源了。一个非常专注的名为 Inject 的微型库，与 InjectionForXcode 搭配使用时，将使您的 Apple 开发更加高效和愉快！
    但不要只相信我的话。看看 Alexandra 和 Nate 的反馈，在我将这个工作流程引入 The Browser Company 设置之前，他们已经非常精通了，这使得它更加令人印象深刻。

Inject

    这个小型库是完全通用的，无论您使用 UIKit、 AppKit 还是 SwiftUI，您都可以使用它。
    您无需为生产应用程序添加条件或删除 Inject 代码。它变成了无操作内联代码，将在非调试版本中被编译过程剥离。您可以在每个视图中集成一次，并持续使用数年。
    请参考 GitHub repo中关于配置项目的说明。现在让我们来看看您有哪些工作流程选项。

工作流

    SwiftUI
        只需要两行字就可以使任何 SwiftUI 启用实时编程，而当您这样做时，您将拥有比使用 Swift Previews 更快的工作流程，同时能够使用实际的生产数据。
        这是我的 Sourcery Pro 应用程序的示例，其中加载了我所有的实际数据和逻辑，使我能够即时快速迭代整个应用程序设计，而无需任何重新启动、重新加载或类似的事情。
        看看这个开发工作流程有多快吧，告诉我你宁愿在我每次接触代码时等待Xcode的重新构建和重新部署。

    UIKit / AppKit
        我们需要一种方法来清理标准命令式UI框架的代码注入阶段之间的状态。
        我创建了 Host 的概念并且在这种情况下工作的很好。有两个：

        - Inject.ViewHost
        - Inject.ViewControllerHost

        我们如何集成它？我们把我们想迭代的类包装在父级，因此我们不修改要注入的类型，而是改变父级的调用站点。
        例如，如果你有一个 SplitViewController ，它创建了 PaneA 和 PaneB ，而你想在PaneA 中迭代布局/逻辑代码，你就修改 SplitViewController 中的调用站点。

        paneA = Inject.ViewHost(
            PaneAView(whatever: arguments, you: want)
        )

        这就是你需要做的所有改变。注入现在允许你更改 PaneAView 中的任何东西，除了它的初始化API。这些变化将立即反映在你的应用程序中。

        一个更具体的例子？
        1、我下载了 Covid19 App
        2、添加 -Xlinker -interposable 到 Other Linker Flags
        3、交换了一行 Covid19TabController.swift:L63 行

        从这句：

        let vc = TwitterViewController(title: Tab.twitter.name, usernames: Twitter.content)

        替换为：

        let vc = Inject.ViewControllerHost(TwitterViewController(title: Tab.twitter.name, usernames: Twitter.content))

        现在，我可以在不重新启动应用程序的情况下迭代控制器设计。

这是如何运作的呢?

逻辑注入如何呢？

它有多可靠？

主要NSObject中的alloc是与自定义类的alloc的源码流程的区别，以及为什么NSObject中的alloc不走源码工程。

在上一篇文章中分析了alloc的源码，这篇文章是作为对上一篇文章的补充，去探索为什么NSObject的alloc方法不走源码工程。

NSObject的alloc无法进入源码的问题

首先在objc4-781可编译源码中的main函数中增加一个NSObject定义的对象，NSObject 和 LGPersong同时加上断点

在alloc的源码实现中加一个断点，同时需要暂时关闭断点

运行target，断点断在NSObject部分，打开alloc源码的断点，然后继续执行，会出现以下这种现象

探索Why

【第一步】探索[NSObject alloc]走的是哪步源码

接下来，我们就来探索为什么NSObject的alloc会出现这种情况，首先，

• 打开Debug --> Debug Workflow --> 勾选 Always Show Disassemly，开启汇编调试

  关闭源码的断点，只留main中的断点，重新运行程序，然后通过下图的汇编可以发现NSObject并没有走 alloc源码，而是走的objc_alloc

然后关闭汇编调试，在全局搜索 objc_alloc，在objc_alloc中加一个断点，先暂时关闭，

重新运行进行调试，断住，然后打开objc_alloc的断点，发现会进入objc_alloc的源码实现，此时查看 cls 是 NSObject

【第二步】探索 NSObject 为什么走 objc_alloc？

首先，我们来看看 NSObject 与 LGPerson的区别

• NSObject 是iOS中的基类，所有自定义的类都需要继承自NSObject
• LGPerson 是继承自NSObject类的，重写了NSObject中的alloc方法

然后根据第一步中汇编的显示，可以看出，NSObject 和 LGPerson 都调用了objc_alloc，所以这里就有两个疑问：

• 为什么NSObject 调用alloc方法 会走到 objc_alloc 源码？
• 为什么LGPerson中的alloc 会走两次？即调用了alloc，进入源码，然后还要走到 objc_alloc？

LGPerson中alloc 走两次 的 Why？

首先，需要在源码中调试，在main中LGPerson加断点，断在LGPerson，再在alloc 、 objc_alloc 和 calloc 源码加断点,运行demo，会断在objc_alloc源码中（重新运行前需要暂时关闭源码中的所有断点）

继续运行，发现LGPerson 第一次的alloc会走到 objc_alloc --> callAlloc方法中最下方的objc_msgSend，表示向系统发送消息

• 继续执行代码，发现会走到 alloc --> callAlloc --> _objc_rootAllocWithZOne，也就是iOS-底层原理 02：alloc & init & new 源码分析源码分析中的alloc流程.

  以下是第二次走到calloc方法中的调用堆栈情况

所以由上述调试过程可以得出，LGPerson走两次的原因是首先需要去查找sel，以及对应的imp的关系，当前需要查找的是 alloc的方法编号，但是为什么会找到objc_alloc？这个就需要问系统了，肯定是系统在底层做了一些操作。请接着往下看

NSObject中alloc 走到 objc_alloc 的 why？

这部分需要通过 LLVM源码（即llvm-project） 来分析

准备工作：首先需要一份llvm源码

在llvm源码中搜索objc_alloc

搜索shouldUseRuntimeFunctionForCombinedAllocInit，表示版本控制

搜索tryEmitSpecializedAllocInit，非常著名的特殊消息发送，在这里也没有找到 objc_alloc

继续尝试，开启上帝视角，通过alloc字符串搜索，如果还找不到，还可以通过omf_alloc:找到tryGenerateSpecializedMessageSend，表示尝试生成特殊消息发送

然后在这个case中可以找到调用alloc，转而调用了objc_objc的逻辑，其中的关键代码是EmitObjCAlloc

跳转至EmitObjCAlloc的定义可以看到alloc 的处理是调用了 objc_alloc

由此可以得出 NSObject中的alloc 会走到 objc_alloc，其实这部分是由系统级别的消息处理逻辑，所以NSObject的初始化是由系统完成的，因此也不会走到alloc的源码工程中

总结

总结下NSObject中alloc 和自定义类中alloc的调用流程

NSObject

自定义类

作者：style_月月
链接：https://blog.csdn.net/lin1109221208/article/details/108480971

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

准备工作

环境版本 & 最新objc源码

• mac OS 10.15
• Xcode 11.4
• objc4-781

依赖文件下载

需要下载以下依赖文件

源码编译

源码编译就是不断的调试修改源码的问题，主要有以下问题

问题一：unable to find sdk 'macosx.internal'

选择 target -> objc -> Build Settings -> Base SDK -> 选择 macOS 【target中的 objc 和 obc-trampolines都需要更改】

问题二：文件找不到的报错问题

【1】‘sys/reason.h’ file not found

在Apple source的 macOS10.15 --> xnu-6153.11.26/bsd/sys/reason.h 路径自行下载

在objc4-781的根目录下新建CJLCommon文件, 同时在CJLCommon文件中创建sys文件

最后将 reason.h文件拷贝到sys文件中

设置文件检索路径：选择 target -> objc -> Build Settings，在工程的 Header Serach Paths 中添加搜索路径 $(SRCROOT)/CJLCommon

【2】‘mach-o/dyld_priv.h’ file not found

• 在CJLCommon文件中 创建 mach-o 文件
• 找到文件：dyld-733.6 -- include -- mach-o -- dyld_priv.h

拷贝到 mach-o文件中

• 拷贝到文件后，还需要修改 dyld_priv.h 文件，即在 dyld_priv.h文件顶部加入一下宏：

【3】‘os/lock_private.h’ file not found 和 ‘os/base_private.h’ file not found

• 在CJLCommon中创建 os文件
• 找到lock_private.h、base_private.h文件：libplatform-220 --> private --> os --> lock_private.h 、base_private.h，并将文件拷贝至 os 文件中

【4】‘pthread/tsd_private.h’ file not found 和 ‘pthread/spinlock_private.h’ file not found

在CJLPerson中创建 pthread 文件
找到tsd_private.h、spinlock_private.h文件，h文件路径为：libpthread-416.11.1 --> private --> tsd_private.h、spinlock_private.h，并拷贝到 pthread文件

【5】‘System/machine/cpu_capabilities.h’ file not found

创建 System -- machine 文件
找到 cpu_capabilities.h文件拷贝到 machine文件，h文件路径为：xnu6153.11.26 --> osfmk --> machine --> cpu_capabilities.h

【6】os/tsd.h’ file not found

找到 tsd.h文件，拷贝到os文件, h文件路径为：xnu6153.11.26 --> libsyscall --> os --> tsd.h

【7】‘System/pthread_machdep.h’ file not found

• 在这个地址下载pthread_machdep.h文件，h文件路径为：Libc-583/pthreads/pthread_machdep.h
• 将其拷贝至system文件中

【8】‘CrashReporterClient.h’ file not found

• 这个文件在改地址搜索 Libc-825.24中找到该文件，路径为Libc-825.24/include/CrashReporterClient.h

导入下载的还是报错，可以通过以下方式解决
- 需要在 Build Settings -> Preprocessor Macros 中加入：LIBC_NO_LIBCRASHREPORTERCLIENT
- 或者下载我给大家的文件CrashReporterClient,这里面我们直接更改了里面的宏信息 #define LIBC_NO_LIBCRASHREPORTERCLIENT

【9】‘objc-shared-cache.h’ file not found

文件路径为：dyld-733.6 --> include --> objc-shared-cache.h

• 将h文件报备制拷贝到CJLCommon

【10】Mismatch in debug-ness macros

注释掉objc-runtime.mm中的#error mismatch in debug-ness macros

【11】’_simple.h’ file not found

文件路径为：libplatform-220 --> private --> _simple.h

• 将文件拷贝至CJLCommon中

• 在CJLCommon中创建kern 文件
• 找到 h文件，路径为xnu-6153.11.26 --> osfmk --> kern -->restartable.h
  

【13】‘Block_private.h’ file not found

找到 h 文件，文件路径为libclosure-74 --> Block_private.h










拷贝至CJLCommon目录

【14】libobjc.order 路径问题

问题描述为：can't open order file: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk/AppleInternal/OrderFiles/libobjc.order

• 选择 target -> objc -> Build Settings

• 在工程的 Order File 中添加搜索路径 $(SRCROOT)/libobjc.order

  
  

  
  

【14】Xcode 脚本编译问题
问题描述为：/xcodebuild:1:1: SDK "macosx.internal" cannot be located.

选择 target -> objc -> Build Phases -> Run Script(markgc)
把脚本文本 macosx.internal 改成 macosx

编译调试

新建一个target ：CJLTest

绑定二进制依赖关系

源码调试

自定义一个CJLPerson类

在main.m中 创建 CJLPerson的对象，进行源码调试

作者：style_月月
链接：https://blog.csdn.net/lin1109221208/article/details/108435967

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

一、目录  

    1、理解二进制在 Swift 中的演变

    2、命令行工具相关

    3、结论

二、前言

    1、理解二进制在 Swift 中的演变

        为了充分理解 Apple 的 Swift 团队在二进制目标和他们引入的一些新 API 方面采取的一些步骤，我们需要理解它们从何而来。在后续的部分中，我们将调研 Apple 架构的演变，以及为什么二进制目标的 API 在过去几年中逐渐形成的，特别是自 Apple 发布了自己的硅芯片之后。

        胖二进制和 Frameworks 框架

        如果你曾必须处理二进制依赖，或者你曾创建一个属于你自己的可执行文件，你将会对 胖二进制 这个术语感到熟悉。这些被扩展（或增大）的可执行文件，是包含了为多个不同架构原生构建的切片。这允许库的所有者分发一个运行在所有预期的目标架构上的单独的二进制。
        当源码不能被暴露或当处理非常庞大的代码仓库时，预编译库成为可执行文件非常有意义，因为预编译源码以及以二进制文件分发他们，将节省构建程序在他们的应用上的构建时间。
        Pods 是一个非常好的例子，当开发者发现他们自己没必要构建那些非常少改动的依赖。这是一个很共通的问题，它激发了诸如 cocoapods-binary之类的项目，该项目预编译了 pod 依赖项以减少客户端的构建时间。

        Frameworks 框架

        嵌入静态二进制文件可能对应用程序来说已经足够了，但如果需要某些资源（如 assets 或头文件），则需要将这些资源与包含所有切片的 胖二进制文件 捆绑在一起，形成所谓的 frameworks 文件。
这就是诸如 Google Cast[5] 之类的预编译库在过渡到使用 xcframework 进行分发之前所做的事情 —— 下一节将详细介绍这种过渡的原因。
        到目前为止，一切都很好。如果我们要为分发预编译一个库，那么胖二进制文件听起来很理想，对吧？并且，如果我们需要捆绑一些其他资源，我们可以只使用一个 frameworks。一个二进制来统治他们所有！

        XCFrameworks 框架

        好吧，不完全是。胖二进制文件有一个大问题，那就是你不能有两个架构相同但命令/指令不同的切片。这曾经很好，因为设备和模拟器的架构总是不同的，但是随着 Apple Silicon 计算机 (M1) 的推出，模拟器和设备共享相同的架构 (arm64)，但具有不同的加载器命令。这与面向未来的二进制目标相结合，正是 Apple 引入 XCFrameworks 的原因。
        XCFrameworks现在允许将多个二进制文件捆绑在一起，解决了 M1 Mac 引入的设备和模拟器冲突架构问题，因为我们现在可以为每个用例提供包含相关切片的二进制文件。事实上，如果我们需要，我们可以走得更远，例如，在同一个 xcframework 中捆绑一个包含 iOS 目标的 UIKit 接口的二进制文件和一个包含 macOS 的 AppKit 接口的二进制文件，然后让 Xcode 基于期望的目标架构决定使用哪一个。
        在 Swift 包中，那先能够以 binaryTarget 被包含进项目的，能够在包中被引入任意其他目标。这相同的操作同样适用于 frameworks。

     2、命令行工具相关

        由于 Swift 5.6 版本中引入了用于 Swift 包管理器的 可扩展构建工具[9] ，因此可以在构建过程中的不同时间执行命令。

        这是 iOS 社区长期以来一直强烈要求的事情，例如格式化源代码、代码生成甚至收集公制代码库的指标。Swift 5.6 中所有这些所谓的 插件最终都需要调用可执行文件来执行特定任务。这是二进制文件再次在 Swift 包中参与的地方。
        在大多数情况下，对于我们 iOS 开发人员来说，这些工具将来自同时支持 macOS 的不同架构切片 —— Apple Silicon 的 arm64 架构和 Intel Mac 的 x86_64 架构。开发者工具如， SwiftLint或 SwiftGen 正是这种案例。在这种情况下，可以使用包含可执行文件（本地或远程）的 .zip 文件的路径创建新的二进制目标。

        Artifact Bundles

        到目前为止，命令行工具所采用的方法仅适用于 macOS 架构。但我们不能忘记，Linux 机器也支持 Swift 包。这意味着如果要同时支持 M1 macs (arm64) 和 Linux arm64 机器，上面的胖二进制方法将不起作用 —— 请记住，二进制不能包含具有相同架构的多个切片。在这个阶段可能有人会想，我们可以不只使用 xcframeworks 吗？不，因为它们在 Linux 操作系统上不受支持！
        Apple 已经考虑到这一点，除了引入 可扩展构建工具[13] 之外，Artifact Bundles和对二进制目标的其他改进也作为 Swift 5.6 的一部分发布。
        工件包(Artifact Bundles) 是包含 工件 的目录。这些工件需要包含支持架构的所有不同二进制文件。二进制文件和支持的架构的路径是使用清单文件 (info.json) 指定的，该文件位于 Artifact Bundle 目录的根目录中。你可以将此清单文件视为一个地图或指南，以帮助 Swift 确定哪些可执行文件可用于哪种架构以及可以在哪里找到它们。

        以 SwiftLint 为例

        SwiftLint 在整个社区中被广泛用作 Swift 代码的静态代码分析工具。由于很多人都非常渴望让这个插件在他们的 SwiftPM 项目中运行，我认为这将是一个很好的例子来展示我们如何将分发的可执行文件从他们的发布页面变成一个与 macOS 架构和 Linux arm64 兼容的工件包。
        让我们从下载两个可执行文件（macOS 和 Linux）开始。
        至此，bundle的结构就可以创建好了。为此，创建一个名为 swiftlint.artifactbundle 的目录并在其根目录添加一个空的 info.json：

        mkdir swiftlint.artifactbundle

        touch swiftlint.artifactbundle/info.json

        现在可以使用 schemaVersion 填充清单文件，这可能会在未来版本的工件包和具有两个变体的工件中发生变化，这将很快定义：

        {

            "schemaVersion": "1.0",
            "artifacts": {
                "swiftlint": {
                    "version": "0.47.0", # The version of SwiftLint being used
                    "type": "executable",
                    "variants": [
                    ]
                },
            }
        }

        需要做的最后一件事是将二进制文件添加到包中，然后将它们作为变体添加到 info.json 文件中。让我们首先创建目录并将二进制文件放入其中（macOS 的一个在 swiftlint-macos/swiftlint，Linux 的一个在 swiftlint-linux/swiftlint）。
        添加这些之后，可以在清单文件中变量：

        {
            "schemaVersion": "1.0",
            "artifacts": {
                "swiftlint": {
                    "version": "0.47.0", # The version of SwiftLint being used
                    "type": "executable",
                    "variants": [
                    {
                        "path": "swiftlint-macos/swiftlint",
                        "supportedTriples": ["x86_64-apple-macosx", "arm64-apple-macosx"]
                    },
                    {
                        "path": "swiftlint-linux/swiftlint",
                        "supportedTriples": ["x86_64-unknown-linux-gnu"]
                    },
                    ]
                },
            }
        }

        为此，需要为每个变量指定二进制文件的相对路径（从工件包目录的根目录）和支持的三元组。如果您不熟悉 目标三元组，它们是一种选择构建二进制文件的架构的方法。请注意，这不是 主机（构建可执行文件的机器）的体系结构，而是 目标 机器（应该运行所述可执行文件的机器）。

        这些三元组具有以下格式： ---- 并非所有字段都是必需的，如果其中一个字段未知并且要使用默认值，则可以省略或替换为 unknown 关键字。
        可执行文件的架构切片可以通过运行 file 找到，这将打印捆绑的任何切片的供应商、系统和架构。在这种情况下，为这两个命令运行它会显示：

        swiftlint-macos/swiftlint

        swiftlint: Mach-O universal binary with 2 architectures: [x86_64:Mach-O 64-bit executable x86_64] [arm64]

        swiftlint (for architecture x86_64): Mach-O 64-bit executable x86_64

        swiftlint (for architecture arm64): Mach-O 64-bit executable arm64

        swiftlint-linux/swiftlint

        -> file swiftlint
        swiftlint: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, with debug_info, not stripped

       这带来了上面显示的 macOS 支持的两个三元组（x86_64-apple-macosx、arm64-apple-macosx）和 Linux 支持的一个三元组（x86_64-unknown-linux-gnu）。

        与 XCFrameworks 类似，工件包也可以通过使用 binaryTarget 包含在 Swift 包中。

    3、结论

        简而言之，我们可以总结 2022 年如何在 Swift 包中使用二进制文件的最佳实践，如下所示：

        1、如果你需要为你的 iOS/macOS 项目添加预编译库或可执行文件，您应该使用 XCFramework，并为每个用例（iOS 设备、macOS 设备和 iOS 模拟器）包含单独的二进制文件。
        2、如果你需要创建一个插件并运行一个可执行文件，你应该将其嵌入为一个工件包，其中包含适用于不同支持架构的二进制文件。

接口API

下面我们先看一下接口的API

/**
 This category adds methods to the UIKit framework's `UIProgressView` class. The methods in this category provide support for binding the progress to the upload and download progress of a session task.
 */
@interface UIProgressView (AFNetworking)

///------------------------------------
/// @name Setting Session Task Progress
///------------------------------------

/**
 Binds the progress to the upload progress of the specified session task.

 @param task The session task.
 @param animated `YES` if the change should be animated, `NO` if the change should happen immediately.
 */
- (void)setProgressWithUploadProgressOfTask:(NSURLSessionUploadTask *)task
                                   animated:(BOOL)animated;

/**
 Binds the progress to the download progress of the specified session task.

 @param task The session task.
 @param animated `YES` if the change should be animated, `NO` if the change should happen immediately.
 */
- (void)setProgressWithDownloadProgressOfTask:(NSURLSessionDownloadTask *)task
                                     animated:(BOOL)animated;

@end

该类为UIKit框架的UIProgressView类添加方法。 此类别中的方法为将进度绑定到会话任务的上载和下载进度提供了支持。

该接口比较少，其实就是一个上传任务和一个下载任务分别和进度的绑定，可动画。

这里大家还要注意一个关于类的继承的细节。

// 上传
@interface NSURLSessionUploadTask : NSURLSessionDataTask
@interface NSURLSessionDataTask : NSURLSessionTask

// 下载
@interface NSURLSessionDownloadTask : NSURLSessionTask

给大家贴出来就是想让大家注意下这个结构。

runtime获取是否可动画

这里还是用runtime分别绑定下载和上传是否可动画。

- (BOOL)af_uploadProgressAnimated {
    return [(NSNumber *)objc_getAssociatedObject(self, @selector(af_uploadProgressAnimated)) boolValue];
}

- (void)af_setUploadProgressAnimated:(BOOL)animated {
    objc_setAssociatedObject(self, @selector(af_uploadProgressAnimated), @(animated), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (BOOL)af_downloadProgressAnimated {
    return [(NSNumber *)objc_getAssociatedObject(self, @selector(af_downloadProgressAnimated)) boolValue];
}

- (void)af_setDownloadProgressAnimated:(BOOL)animated {
    objc_setAssociatedObject(self, @selector(af_downloadProgressAnimated), @(animated), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

这个还算是很好理解的，有了前面的基础，这里就不多说了。

接口的实现

下面我们就看一下接口的实现。

1. 上传任务

static void * AFTaskCountOfBytesSentContext = &AFTaskCountOfBytesSentContext;
static void * AFTaskCountOfBytesReceivedContext = &AFTaskCountOfBytesReceivedContext;

- (void)setProgressWithUploadProgressOfTask:(NSURLSessionUploadTask *)task
                                   animated:(BOOL)animated
{
    if (task.state == NSURLSessionTaskStateCompleted) {
        return;
    }
    
    [task addObserver:self forKeyPath:@"state" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesSentContext];
    [task addObserver:self forKeyPath:@"countOfBytesSent" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesSentContext];

    [self af_setUploadProgressAnimated:animated];
}

这里逻辑很清晰，简单的说一下，如果任务是完成状态，那么就直接return，然后给task添加KVO观察，观察属性是state和countOfBytesSent，最后就是设置是否可动画的状态。

2. 下载任务

- (void)setProgressWithDownloadProgressOfTask:(NSURLSessionDownloadTask *)task
                                     animated:(BOOL)animated
{
    if (task.state == NSURLSessionTaskStateCompleted) {
        return;
    }
    
    [task addObserver:self forKeyPath:@"state" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesReceivedContext];
    [task addObserver:self forKeyPath:@"countOfBytesReceived" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesReceivedContext];

    [self af_setDownloadProgressAnimated:animated];
}

这里逻辑很清晰，简单的说一下，如果任务是完成状态，那么就直接return，然后给task添加KVO观察，观察属性是state和countOfBytesReceived，最后就是设置是否可动画的状态。

KVO观察实现

下面看一下KVO观察的实现，这里也是这个类的精髓所在。

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(__unused NSDictionary *)change
                       context:(void *)context
{
    if (context == AFTaskCountOfBytesSentContext || context == AFTaskCountOfBytesReceivedContext) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesSent))]) {
            if ([object countOfBytesExpectedToSend] > 0) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [self setProgress:[object countOfBytesSent] / ([object countOfBytesExpectedToSend] * 1.0f) animated:self.af_uploadProgressAnimated];
                });
            }
        }

        if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesReceived))]) {
            if ([object countOfBytesExpectedToReceive] > 0) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [self setProgress:[object countOfBytesReceived] / ([object countOfBytesExpectedToReceive] * 1.0f) animated:self.af_downloadProgressAnimated];
                });
            }
        }

        if ([keyPath isEqualToString:NSStringFromSelector(@selector(state))]) {
            if ([(NSURLSessionTask *)object state] == NSURLSessionTaskStateCompleted) {
                @try {
                    [object removeObserver:self forKeyPath:NSStringFromSelector(@selector(state))];

                    if (context == AFTaskCountOfBytesSentContext) {
                        [object removeObserver:self forKeyPath:NSStringFromSelector(@selector(countOfBytesSent))];
                    }

                    if (context == AFTaskCountOfBytesReceivedContext) {
                        [object removeObserver:self forKeyPath:NSStringFromSelector(@selector(countOfBytesReceived))];
                    }
                }
                @catch (NSException * __unused exception) {}
            }
        }
    }
}

这里还是很简单的吧。

• 如果keyPath是@"countOfBytesSent"，那么就获取countOfBytesExpectedToSend，计算进度百分比，在主线程调用[self setProgress:[object countOfBytesSent] / ([object countOfBytesExpectedToSend] * 1.0f) animated:self.af_uploadProgressAnimated];得到进度。
• 如果keyPath是@"countOfBytesReceived"，那么就获取countOfBytesExpectedToReceive，计算进度百分比，在主线程调用[self setProgress:[object countOfBytesReceived] / ([object countOfBytesExpectedToReceive] * 1.0f) animated:self. af_downloadProgressAnimated];得到进度。
• 如果keyPath是@"state"并且任务是完成状态NSURLSessionTaskStateCompleted，那么就要移除对这几个keyPath的观察者。

后记

本篇主要分析了UIProgressView+AFNetworking分类，主要实现了上传任务和下载任务与进度之间的绑定。

转载自：https://cloud.tencent.com/developer/article/1872398

回顾

上一篇主要分析了UIProgressView+AFNetworking分类，主要实现了上传任务和下载任务与进度之间的绑定。这一篇主要分析UIRefreshControl+AFNetworking这个分类。

接口API

下面我们先看一下接口的API

/**
 This category adds methods to the UIKit framework's `UIProgressView` class. The methods in this category provide support for binding the progress to the upload and download progress of a session task.
 */
@interface UIProgressView (AFNetworking)

///------------------------------------
/// @name Setting Session Task Progress
///------------------------------------

/**
 Binds the progress to the upload progress of the specified session task.

 @param task The session task.
 @param animated `YES` if the change should be animated, `NO` if the change should happen immediately.
 */
- (void)setProgressWithUploadProgressOfTask:(NSURLSessionUploadTask *)task
                                   animated:(BOOL)animated;

/**
 Binds the progress to the download progress of the specified session task.

 @param task The session task.
 @param animated `YES` if the change should be animated, `NO` if the change should happen immediately.
 */
- (void)setProgressWithDownloadProgressOfTask:(NSURLSessionDownloadTask *)task
                                     animated:(BOOL)animated;

@end

该类为UIKit框架的UIProgressView类添加方法。 此类别中的方法为将进度绑定到会话任务的上载和下载进度提供了支持。

该接口比较少，其实就是一个上传任务和一个下载任务分别和进度的绑定，可动画。

这里大家还要注意一个关于类的继承的细节。

// 上传
@interface NSURLSessionUploadTask : NSURLSessionDataTask
@interface NSURLSessionDataTask : NSURLSessionTask

// 下载
@interface NSURLSessionDownloadTask : NSURLSessionTask

给大家贴出来就是想让大家注意下这个结构。

---

runtime获取是否可动画

这里还是用runtime分别绑定下载和上传是否可动画。

- (BOOL)af_uploadProgressAnimated {
    return [(NSNumber *)objc_getAssociatedObject(self, @selector(af_uploadProgressAnimated)) boolValue];
}

- (void)af_setUploadProgressAnimated:(BOOL)animated {
    objc_setAssociatedObject(self, @selector(af_uploadProgressAnimated), @(animated), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (BOOL)af_downloadProgressAnimated {
    return [(NSNumber *)objc_getAssociatedObject(self, @selector(af_downloadProgressAnimated)) boolValue];
}

- (void)af_setDownloadProgressAnimated:(BOOL)animated {
    objc_setAssociatedObject(self, @selector(af_downloadProgressAnimated), @(animated), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

这个还算是很好理解的，有了前面的基础，这里就不多说了。

---

接口的实现

下面我们就看一下接口的实现。

1. 上传任务

static void * AFTaskCountOfBytesSentContext = &AFTaskCountOfBytesSentContext;
static void * AFTaskCountOfBytesReceivedContext = &AFTaskCountOfBytesReceivedContext;

- (void)setProgressWithUploadProgressOfTask:(NSURLSessionUploadTask *)task
                                   animated:(BOOL)animated
{
    if (task.state == NSURLSessionTaskStateCompleted) {
        return;
    }
    
    [task addObserver:self forKeyPath:@"state" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesSentContext];
    [task addObserver:self forKeyPath:@"countOfBytesSent" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesSentContext];

    [self af_setUploadProgressAnimated:animated];
}

这里逻辑很清晰，简单的说一下，如果任务是完成状态，那么就直接return，然后给task添加KVO观察，观察属性是state和countOfBytesSent，最后就是设置是否可动画的状态。

2. 下载任务

- (void)setProgressWithDownloadProgressOfTask:(NSURLSessionDownloadTask *)task
                                     animated:(BOOL)animated
{
    if (task.state == NSURLSessionTaskStateCompleted) {
        return;
    }
    
    [task addObserver:self forKeyPath:@"state" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesReceivedContext];
    [task addObserver:self forKeyPath:@"countOfBytesReceived" options:(NSKeyValueObservingOptions)0 context:AFTaskCountOfBytesReceivedContext];

    [self af_setDownloadProgressAnimated:animated];
}

这里逻辑很清晰，简单的说一下，如果任务是完成状态，那么就直接return，然后给task添加KVO观察，观察属性是state和countOfBytesReceived，最后就是设置是否可动画的状态。

KVO观察实现

下面看一下KVO观察的实现，这里也是这个类的精髓所在。

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(__unused NSDictionary *)change
                       context:(void *)context
{
    if (context == AFTaskCountOfBytesSentContext || context == AFTaskCountOfBytesReceivedContext) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesSent))]) {
            if ([object countOfBytesExpectedToSend] > 0) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [self setProgress:[object countOfBytesSent] / ([object countOfBytesExpectedToSend] * 1.0f) animated:self.af_uploadProgressAnimated];
                });
            }
        }

        if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesReceived))]) {
            if ([object countOfBytesExpectedToReceive] > 0) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [self setProgress:[object countOfBytesReceived] / ([object countOfBytesExpectedToReceive] * 1.0f) animated:self.af_downloadProgressAnimated];
                });
            }
        }

        if ([keyPath isEqualToString:NSStringFromSelector(@selector(state))]) {
            if ([(NSURLSessionTask *)object state] == NSURLSessionTaskStateCompleted) {
                @try {
                    [object removeObserver:self forKeyPath:NSStringFromSelector(@selector(state))];

                    if (context == AFTaskCountOfBytesSentContext) {
                        [object removeObserver:self forKeyPath:NSStringFromSelector(@selector(countOfBytesSent))];
                    }

                    if (context == AFTaskCountOfBytesReceivedContext) {
                        [object removeObserver:self forKeyPath:NSStringFromSelector(@selector(countOfBytesReceived))];
                    }
                }
                @catch (NSException * __unused exception) {}
            }
        }
    }
}

这里还是很简单的吧。

• 如果keyPath是@"countOfBytesSent"，那么就获取countOfBytesExpectedToSend，计算进度百分比，在主线程调用[self setProgress:[object countOfBytesSent] / ([object countOfBytesExpectedToSend] * 1.0f) animated:self.af_uploadProgressAnimated];得到进度。
• 如果keyPath是@"countOfBytesReceived"，那么就获取countOfBytesExpectedToReceive，计算进度百分比，在主线程调用[self setProgress:[object countOfBytesReceived] / ([object countOfBytesExpectedToReceive] * 1.0f) animated:self. af_downloadProgressAnimated];得到进度。
• 如果keyPath是@"state"并且任务是完成状态NSURLSessionTaskStateCompleted，那么就要移除对这几个keyPath的观察者。

后记

本篇主要分析了UIProgressView+AFNetworking分类，主要实现了上传任务和下载任务与进度之间的绑定。

本文转载自腾讯社区:作者conanma  https://cloud.tencent.com/developer/article/1872401

回顾

上一篇主要讲述了UIRefreshControl+AFNetworking这个分类，将刷新状态和任务状态进行了绑定和同步。这一篇主要讲述AFAutoPurgingImageCache有关的缓存。

接口API

按照老惯例，我们还是先看一下接口API文档。这个接口文档包括三个部分，两个协议一个类。

• 协议AFImageCache
• 协议AFImageRequestCache
• 类AFAutoPurgingImageCache

1. AFImageCache

这个协议包括四个方法

/**
 Adds the image to the cache with the given identifier.

 @param image The image to cache.
 @param identifier The unique identifier for the image in the cache.
 */
- (void)addImage:(UIImage *)image withIdentifier:(NSString *)identifier;

/**
 Removes the image from the cache matching the given identifier.

 @param identifier The unique identifier for the image in the cache.

 @return A BOOL indicating whether or not the image was removed from the cache.
 */
- (BOOL)removeImageWithIdentifier:(NSString *)identifier;

/**
 Removes all images from the cache.

 @return A BOOL indicating whether or not all images were removed from the cache.
 */
- (BOOL)removeAllImages;

/**
 Returns the image in the cache associated with the given identifier.

 @param identifier The unique identifier for the image in the cache.

 @return An image for the matching identifier, or nil.
 */
- (nullable UIImage *)imageWithIdentifier:(NSString *)identifier;

该协议定义了包括加入、移除、获取缓存中的图片。

2. AFImageRequestCache

该协议包含下面几个方法，这里注意这个协议继承自协议AFImageCache

@protocol AFImageRequestCache <AFImageCache>

/**
 Asks if the image should be cached using an identifier created from the request and additional identifier.
 
 @param image The image to be cached.
 @param request The unique URL request identifing the image asset.
 @param identifier The additional identifier to apply to the URL request to identify the image.
 
 @return A BOOL indicating whether or not the image should be added to the cache. YES will cache, NO will prevent caching.
 */
- (BOOL)shouldCacheImage:(UIImage *)image forRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

/**
 Adds the image to the cache using an identifier created from the request and additional identifier.

 @param image The image to cache.
 @param request The unique URL request identifing the image asset.
 @param identifier The additional identifier to apply to the URL request to identify the image.
 */
- (void)addImage:(UIImage *)image forRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

/**
 Removes the image from the cache using an identifier created from the request and additional identifier.

 @param request The unique URL request identifing the image asset.
 @param identifier The additional identifier to apply to the URL request to identify the image.
 
 @return A BOOL indicating whether or not all images were removed from the cache.
 */
- (BOOL)removeImageforRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

/**
 Returns the image from the cache associated with an identifier created from the request and additional identifier.

 @param request The unique URL request identifing the image asset.
 @param identifier The additional identifier to apply to the URL request to identify the image.

 @return An image for the matching request and identifier, or nil.
 */
- (nullable UIImage *)imageforRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

@end

根据请求和标识对图像进行是否需要缓存、加入到缓存或者移除缓存等进行操作。

3. AFAutoPurgingImageCache

这个是这个类的接口，大家注意下这个类遵循协议AFImageRequestCache。

/**
 The `AutoPurgingImageCache` in an in-memory image cache used to store images up to a given memory capacity. When the memory capacity is reached, the image cache is sorted by last access date, then the oldest image is continuously purged until the preferred memory usage after purge is met. Each time an image is accessed through the cache, the internal access date of the image is updated.
 */
@interface AFAutoPurgingImageCache : NSObject <AFImageRequestCache>

/**
 The total memory capacity of the cache in bytes.
 */
// 内存缓存总的字节数
@property (nonatomic, assign) UInt64 memoryCapacity;

/**
 The preferred memory usage after purge in bytes. During a purge, images will be purged until the memory capacity drops below this limit.
 */
// 以字节为单位清除后的首选内存使用情况。 在清除过程中，图像将被清除，直到内存容量降至此限制以下。
@property (nonatomic, assign) UInt64 preferredMemoryUsageAfterPurge;

/**
 The current total memory usage in bytes of all images stored within the cache.
 */
// 当前所有图像内存缓存使用的总的字节数
@property (nonatomic, assign, readonly) UInt64 memoryUsage;

/**
 Initialies the `AutoPurgingImageCache` instance with default values for memory capacity and preferred memory usage after purge limit. `memoryCapcity` defaults to `100 MB`. `preferredMemoryUsageAfterPurge` defaults to `60 MB`.
// 初始化，memoryCapcity为100M，preferredMemoryUsageAfterPurge为60M

 @return The new `AutoPurgingImageCache` instance.
 */
- (instancetype)init;

/**
 Initialies the `AutoPurgingImageCache` instance with the given memory capacity and preferred memory usage
 after purge limit.

 @param memoryCapacity The total memory capacity of the cache in bytes.
 @param preferredMemoryCapacity The preferred memory usage after purge in bytes.

 @return The new `AutoPurgingImageCache` instance.
 */
- (instancetype)initWithMemoryCapacity:(UInt64)memoryCapacity preferredMemoryCapacity:(UInt64)preferredMemoryCapacity;

@end

内存中图像缓存中的AutoPurgingImageCache用于存储图像到给定内存容量。 达到内存容量时，图像缓存按上次访问日期排序，然后最旧的图像不断清除，直到满足清除后的首选内存使用量。 每次通过缓存访问图像时，图像的内部访问日期都会更新。

AFAutoPurgingImageCache接口及初始化

从接口描述中我们可以看出来，类的初始化规定了内存总的使用量以及清楚以后的内存最优大小。

- (instancetype)init {
    return [self initWithMemoryCapacity:100 * 1024 * 1024 preferredMemoryCapacity:60 * 1024 * 1024];
}

- (instancetype)initWithMemoryCapacity:(UInt64)memoryCapacity preferredMemoryCapacity:(UInt64)preferredMemoryCapacity {
    if (self = [super init]) {
        self.memoryCapacity = memoryCapacity;
        self.preferredMemoryUsageAfterPurge = preferredMemoryCapacity;
        self.cachedImages = [[NSMutableDictionary alloc] init];

        NSString *queueName = [NSString stringWithFormat:@"com.alamofire.autopurgingimagecache-%@", [[NSUUID UUID] UUIDString]];
        self.synchronizationQueue = dispatch_queue_create([queueName cStringUsingEncoding:NSASCIIStringEncoding], DISPATCH_QUEUE_CONCURRENT);

        [[NSNotificationCenter defaultCenter]
         addObserver:self
         selector:@selector(removeAllImages)
         name:UIApplicationDidReceiveMemoryWarningNotification
         object:nil];

    }
    return self;
}

我们看一下这个初始化方法中都做了什么事情

设置置缓存图像的字典

self.cachedImages = [[NSMutableDictionary alloc] init];

常见和UUID关联的并发队列

NSString *queueName = [NSString stringWithFormat:@"com.alamofire.autopurgingimagecache-%@", [[NSUUID UUID] UUIDString]];
self.synchronizationQueue = dispatch_queue_create([queueName cStringUsingEncoding:NSASCIIStringEncoding], DISPATCH_QUEUE_CONCURRENT);

增加移除所有图像的通知

[[NSNotificationCenter defaultCenter]
         addObserver:self
         selector:@selector(removeAllImages)
         name:UIApplicationDidReceiveMemoryWarningNotification
         object:nil];

- (BOOL)removeAllImages {
    __block BOOL removed = NO;
    dispatch_barrier_sync(self.synchronizationQueue, ^{
        if (self.cachedImages.count > 0) {
            [self.cachedImages removeAllObjects];
            self.currentMemoryUsage = 0;
            removed = YES;
        }
    });
    return removed;
}

这里就是在上面生成的队列中，清空数组，重置一些属性值。

AFCachedImage接口及初始化

这里我们就看一下AFCachedImage的接口及初始化。

@interface AFCachedImage : NSObject

@property (nonatomic, strong) UIImage *image;
@property (nonatomic, strong) NSString *identifier;
@property (nonatomic, assign) UInt64 totalBytes;
@property (nonatomic, strong) NSDate *lastAccessDate;
@property (nonatomic, assign) UInt64 currentMemoryUsage;

@end

- (instancetype)initWithImage:(UIImage *)image identifier:(NSString *)identifier {
    if (self = [self init]) {
        self.image = image;
        self.identifier = identifier;

        CGSize imageSize = CGSizeMake(image.size.width * image.scale, image.size.height * image.scale);
        CGFloat bytesPerPixel = 4.0;
        CGFloat bytesPerSize = imageSize.width * imageSize.height;
        self.totalBytes = (UInt64)bytesPerPixel * (UInt64)bytesPerSize;
        self.lastAccessDate = [NSDate date];
    }
    return self;
}

这个初始化方法里面初始化图像的字节数，并更新上次获取数据的时间。

协议方法的实现

1. AFImageCache协议的实现

将图像根据标识添加到内存

- (void)addImage:(UIImage *)image withIdentifier:(NSString *)identifier;

- (void)addImage:(UIImage *)image withIdentifier:(NSString *)identifier {
    dispatch_barrier_async(self.synchronizationQueue, ^{
        AFCachedImage *cacheImage = [[AFCachedImage alloc] initWithImage:image identifier:identifier];

        AFCachedImage *previousCachedImage = self.cachedImages[identifier];
        if (previousCachedImage != nil) {
            self.currentMemoryUsage -= previousCachedImage.totalBytes;
        }

        self.cachedImages[identifier] = cacheImage;
        self.currentMemoryUsage += cacheImage.totalBytes;
    });

    dispatch_barrier_async(self.synchronizationQueue, ^{
        if (self.currentMemoryUsage > self.memoryCapacity) {
            UInt64 bytesToPurge = self.currentMemoryUsage - self.preferredMemoryUsageAfterPurge;
            NSMutableArray <AFCachedImage*> *sortedImages = [NSMutableArray arrayWithArray:self.cachedImages.allValues];
            NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"lastAccessDate"
                                                                           ascending:YES];
            [sortedImages sortUsingDescriptors:@[sortDescriptor]];

            UInt64 bytesPurged = 0;

            for (AFCachedImage *cachedImage in sortedImages) {
                [self.cachedImages removeObjectForKey:cachedImage.identifier];
                bytesPurged += cachedImage.totalBytes;
                if (bytesPurged >= bytesToPurge) {
                    break ;
                }
            }
            self.currentMemoryUsage -= bytesPurged;
        }
    });
}

这里用到了两个阻塞

第一个阻塞

dispatch_barrier_async(self.synchronizationQueue, ^{
    AFCachedImage *cacheImage = [[AFCachedImage alloc] initWithImage:image identifier:identifier];

    AFCachedImage *previousCachedImage = self.cachedImages[identifier];
    if (previousCachedImage != nil) {
        self.currentMemoryUsage -= previousCachedImage.totalBytes;
    }

    self.cachedImages[identifier] = cacheImage;
    self.currentMemoryUsage += cacheImage.totalBytes;
});

这里的作用其实很清楚，就是先根据image和identify实例化AFCachedImage对象。然后在字典中根据identifier查看是否有AFCachedImage对象，如果有的话，那么就减小当前使用内存的值。并将前面实例化的AFCachedImage对象存入字典中，并增加当前使用内存的值。

第二个阻塞

dispatch_barrier_async(self.synchronizationQueue, ^{
    if (self.currentMemoryUsage > self.memoryCapacity) {
        UInt64 bytesToPurge = self.currentMemoryUsage - self.preferredMemoryUsageAfterPurge;
        NSMutableArray <AFCachedImage*> *sortedImages = [NSMutableArray arrayWithArray:self.cachedImages.allValues];
        NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"lastAccessDate"
                                                                       ascending:YES];
        [sortedImages sortUsingDescriptors:@[sortDescriptor]];

        UInt64 bytesPurged = 0;

        for (AFCachedImage *cachedImage in sortedImages) {
            [self.cachedImages removeObjectForKey:cachedImage.identifier];
            bytesPurged += cachedImage.totalBytes;
            if (bytesPurged >= bytesToPurge) {
                break ;
            }
        }
        self.currentMemoryUsage -= bytesPurged;
    }
});

这里完成的功能是，首先判断如果当前内存使用量大于内存总量，那么就需要清理了，这里需要计算需要清理多少内存，就是当前内存值 - 最优内存值。然后sortedImages实例化字典中所有的图片，并对这些图片进行按照时间的排序，遍历这个排序后的数组，逐一从字典中移除，终止条件就是移除的字节数大于上面计算的要清除的字节数值。最后，更新下当前内存使用的值。

根据指定标识将图像移出内存

- (BOOL)removeImageWithIdentifier:(NSString *)identifier;

- (BOOL)removeImageWithIdentifier:(NSString *)identifier {
    __block BOOL removed = NO;
    dispatch_barrier_sync(self.synchronizationQueue, ^{
        AFCachedImage *cachedImage = self.cachedImages[identifier];
        if (cachedImage != nil) {
            [self.cachedImages removeObjectForKey:identifier];
            self.currentMemoryUsage -= cachedImage.totalBytes;
            removed = YES;
        }
    });
    return removed;
}

这个还是很好理解的，在定义的并行队列中，取出identifier对应的AFCachedImage对象，然后从字典中移除，并更新当前内存的值。

从内存中移除所有的图像

- (BOOL)removeAllImages;

- (BOOL)removeAllImages {
    __block BOOL removed = NO;
    dispatch_barrier_sync(self.synchronizationQueue, ^{
        if (self.cachedImages.count > 0) {
            [self.cachedImages removeAllObjects];
            self.currentMemoryUsage = 0;
            removed = YES;
        }
    });
    return removed;
}

其实就是一句话，清空字典，更新当前内存使用值。

根据指定的标识符从内存中获取图像

- (nullable UIImage *)imageWithIdentifier:(NSString *)identifier;

- (nullable UIImage *)imageWithIdentifier:(NSString *)identifier {
    __block UIImage *image = nil;
    dispatch_sync(self.synchronizationQueue, ^{
        AFCachedImage *cachedImage = self.cachedImages[identifier];
        image = [cachedImage accessImage];
    });
    return image;
}

- (UIImage*)accessImage {
    self.lastAccessDate = [NSDate date];
    return self.image;
}

其实就是从字典中取值，并更新上次获取图像的时间。

2. AFImageRequestCache协议的实现

根据请求和标识符将图像加入到内存

- (void)addImage:(UIImage *)image forRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

- (void)addImage:(UIImage *)image forRequest:(NSURLRequest *)request withAdditionalIdentifier:(NSString *)identifier {
    [self addImage:image withIdentifier:[self imageCacheKeyFromURLRequest:request withAdditionalIdentifier:identifier]];
}

- (NSString *)imageCacheKeyFromURLRequest:(NSURLRequest *)request withAdditionalIdentifier:(NSString *)additionalIdentifier {
    NSString *key = request.URL.absoluteString;
    if (additionalIdentifier != nil) {
        key = [key stringByAppendingString:additionalIdentifier];
    }
    return key;
}

这里其实是调用上面我们讲过的那个根据identifier取出AFCachedImage对象的那个方法。不过下面这个identifier是通过调用下面这个方法生成的。、

根据请求和标识符将图像移出内存

- (BOOL)removeImageforRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

- (BOOL)removeImageforRequest:(NSURLRequest *)request withAdditionalIdentifier:(NSString *)identifier {
    return [self removeImageWithIdentifier:[self imageCacheKeyFromURLRequest:request withAdditionalIdentifier:identifier]];
}

这个，就是还是利用那个生成indentifier的方法，获取identify，然后调用前面我们讲过的方法移除对应的图像。

根据请求和标识符获取内存中图像

- (nullable UIImage *)imageforRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

- (nullable UIImage *)imageforRequest:(NSURLRequest *)request withAdditionalIdentifier:(NSString *)identifier {
    return [self imageWithIdentifier:[self imageCacheKeyFromURLRequest:request withAdditionalIdentifier:identifier]];
}

这个，就是还是利用那个生成indentifier的方法，获取identify，然后调用前面我们讲过的方法获取对应的图像。

是否将图像缓存到内存

- (BOOL)shouldCacheImage:(UIImage *)image forRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier;

- (BOOL)shouldCacheImage:(UIImage *)image forRequest:(NSURLRequest *)request withAdditionalIdentifier:(nullable NSString *)identifier {
    return YES;
}

本文转载自：https://cloud.tencent.com/developer/article/1872403

ios15适配

• 1、UITabar、NaBar新增scrollEdgeAppearance，来描述滚动视图滚动到bar边缘时的外观，即使没有滚动视图也需要去指定scrollEdgeAppearance，否则可能导致bar的背景设置无效。具体可以参考UIBarAppearance
• 2、tableView 增加sectionHeaderTopPadding属性，默认值是UITableViewAutomaticDimension，可能会使tableView sectionHeader多处一段距离，需要设置 为
• 3、IDFA 请求权限不弹框问题，解决参考iOS15 ATTrackingManager请求权限不弹框
• 4、iOS15终于迎来了UIButton的这个改动

ios14适配

• 1、更改了cell布局视图，之前将视图加载在cell上,将会出现contentView遮罩,导致事件无法响应,必须将customView 放在 contentView 上
• 2、UIDatePicker默认样式不再是以前的，需要设置preferredDatePickerStyle为 UIDatePickerStyleWheels。
• 3、IDFA必须要用户用户授权处理，否则获取不到IDFA
• 4、 UIPageControl的变化 具体参考iOS 14 UIPageControl对比、升级与适配

ios13适配

-1、 iOS 13 推出暗黑模式，UIKit 提供新的系统颜色和 api 来适配不同颜色模式，xcassets 对素材适配也做了调整

• 2、支持第三方登录必须，就必须Sign In with Apple
• 3、MPMoviePlayerController 废弃
• 4、iOS 13 DeviceToken有变化
• 5、模态弹出默认不再是全屏。
• 6、私有方法 KVC 不允许使用
• 7、蓝牙权限需要申请
• 8、LaunchImage 被弃用
• 9、新出UIBarAppearance统一配置navigation bars、tab bars、 toolbars等bars的外观。之前设置na bar和tab bar外观的方法可能会无效

ios12适配

• 1、C++ 标准库libstdc++相关的3个库(libstdc++、libstdc++.6、libstdc++6.0.9 ）废弃，使用libc++代替
• 2、短信 验证码自动填充api

if (@available(iOS 12.0, *)) {

        codeTextFiled.textContentType = UITextContentTypeOneTimeCode;

    }

ios11适配

• 1、ViewController的automaticallyAdjustsScrollViewInsets属性被废弃，用scrollView的contentInsetAdjustmentBehavior代替。
• 2、safeAreaLayoutGuide的引入
• 3、tableView默认开启了Size-self
• 4、新增的prefersLargeTitles属性
• 5、改善圆角，layer新增了maskedCorners属性
• 6、tableView右滑删除新增api
• 7、导航条的层级发生了变化。
  ios11适配相关

ios10适配

• 1、通知统一使用UserNotifications.framework框架
• 2、UICollectionViewCell的的优化，新增加Pre-Fetching预加载机制
• 3、苹果加强了对隐私数据的保护，要对隐私数据权限做一个适配，iOS10调用相机，访问通讯录，访问相册等都要在info.plist中加入权限访问描述，不然之前你们的项目涉及到这些权限的地方就会直接crash掉。
• 4、AVPlayer增加了多个属性，timeControlStatus、
  automaticallyWaitsToMinimizeStalling
• 5、tabar未选中颜色设置 用 unselectedItemTintColor代替

大家好啊，新手一枚，请多关照哈。。。。。。。。。。

在项目开发中，很多地方用到了列表，而 React-Native 官网中提供的组件 ListView，虽然能够满足我们的需求，但是性能问题并没有很好的解决，对于需要展现大量数据的列表，app 的内存将会非常庞大。针对 React-Native 的列表性能问题，现在提供几套可行性方案：

1.利用 Facebook 提供的建议对 ListView 进行优化

Facebook 官方对 ListView 的性能优化做了简单介绍，并提供了以下几个方法：

• initialListSize
• 这个属性用来指定我们第一次渲染时，要读取的行数。如果我们想尽可能的快，我们可以设置它为1, 然后可以在后续的帧中，填弃其它的行。每一次读取的行数，由 pageSize 决定.
• pageSize
• 在使用了 initialListSize 之后，ListView 根据 pageSize 来决定每一帧读取的行数，默认值为1, 但如果你的的 views 非常的小，并且读取时占的资源很少, 你可以调整这个值，在找到适合你的值。
• scrollRenderAheadDistance
• 如果我们的列表有2000个项，而让它一次性读取，它会导致内存和计算资源的耗尽。所以 scrollRenderAhead distance 可以指定，超出当前视图多少，继续宣染。
• removeClippedSubviews
• “当它设置为true时，当本地端的superview为offscreen时 ，不在屏幕上显示的子视图offscreen（它的overflow的值为hidden) 会被删除。它可以改善长列表的滚动的性能，默认值为true.
  这对于大的ListViews来说是一个非常重要。在Android, overflow的值通常为hidden. 所以我们并不需要担心它的设置，但是对于iOS来说，你需要设置row Container的样式为overflow: hidden。

在使用了上述方法后，我们可以看到app的内存占用有了一定的下降（加载100张图片时的效果）：

使用前：

使用后：

3.桥接 Native tableview

第二种方法里面，能够比较好的解决屏幕外的 cell 内存问题，但是和 native tableview 相比，并没有 native 的 cell 重用机制完美，那么，我们可以讲 native 的 tableview 桥接到 React-native 中来，让我们可以在 React-Native 中也可以重用 cell

我们创建一些 VirtualView，他只是遵从了 RCTComponent 协议，其实并不是一个真正的 View，我把它形成一个组件，把它 Bridge 到 JS，这就使得，你在写 JSX 的时候，就可以直接用 VirtualView 来去做布局了。在RN里面做布局的时候我们用VirtualView来做布局。但是最终在 insertReactSubview 时，我们把这些 VirtualView 当做数据去处理，通过 VirtualView 和RealView 的对应关系，把它转化成一个真实的 View 对象添加到 TableView 中去。

但是使用这种方法，我们需要将 tableview 的所有常用数据源方法和代理方法都桥接到 React-Native 中来，甚至对于一些 cell 组件，我们也需要自己桥接，并不能像 React-Native 那样使用自己的组件。当我们的需求比较复杂或者需求发生变化时，就需要重新桥接我们的自定义 cell，这样工作量就会比较大。大多数的 cell 里面如果做展示来用的话，Label 和 Image 基本上能够满足大多数的需求了。所以我们现在只是做了 Label 和 Image 的对应工作，但在 RN 的一些官方控件，在这个 view 里面都是没法直接使用的。

4.用 JS 实现一套 cell 重用的逻辑

基于 RN 的 ScrollView，我们也监听 OnScroll()，他往上滑的时候，我们需要把上面的 cellComponent 挪下来，挪到上面去用。但是这个方式最终的效果并不是特别好。

问题在于，如果我们所有的 Cell 都是一样高的，里面的元素不是很多的情况下，性能还相对好一些，我们每次 OnScroll 的时候，他处理的Cell比较少。如果你希望有一个界面滚动能够达到流畅的话，所有的处理都需要在 16ms 内完成，但是这又造成了 onScroll 都要去刷新页面，导致这样的交互会非常非常多，导致你从 JS，到 native 的 bridge 要频繁的通讯，JS 中的很多处理方式都是异步的，使得这个方案的效果没有达到很好的预期。

总结

从上面的几种方案可以看出，方案1、2、3、4都能够比较好的解决列表的性能问题 ，而且各有优缺点，那么，我们在项目开发中该如何应用呢？

• 当我们在进行列表展示的时候，如果数据量不是特别的庞大（不是无限滚动的），且界面比较复杂的时候，方案1能够比较好的解决性能问题，而且操作起来比较简单，只需要对 listview 的一些属性进行基本设置。
• 当我们需要展示很多数据的时候（不是无限滚动的），我们可以使用方案2，对那些超出屏幕外的部分，对他进行组件最小化
• 当我们需要展示大量数据（可以无限滚动的），我们可以通过方案3/4，来达到重用的目的

本文转载自：https://cloud.tencent.com/developer/article/1930849

在分析alloc源码之前，先来看看一下3个变量 内存地址 和 指针地址 区别：

分别输出3个对象的内容、内存地址、指针地址，下图是打印结果

结论：通过上图可以看出，3个对象指向的是同一个内存空间，所以其内容 和 内存地址是相同的，但是对象的指针地址是不同的

%p -> &p1：是对象的指针地址，
%p -> p1： 是对象指针指向的的内存地址

这就是本文需要探索的内容，alloc做了什么？init做了什么？

准备工作

• 下载 objc4-781 源码
• 编译源码，可参考iOS-底层原理 03：objc4-781 源码编译 & 调试

alloc 源码探索

alloc + init 整体源码的探索流程如下

• 【第一步】首先根据main函数中的LGPerson类的alloc方法进入alloc方法的源码实现（即源码分析开始），

• 【第二步】跳转至_objc_rootAlloc的源码实现

• 【第三步】跳转至callAlloc的源码实现

如上所示，在calloc方法中，当我们无法确定实现走到哪步时，可以通过断点调试，判断执行走哪部分逻辑。这里是执行到_objc_rootAllocWithZone

slowpath & fastpath

其中关于slowpath和fastpath这里需要简要说明下，这两个都是objc源码中定义的宏，其定义如下

其中的__builtin_expect指令是由gcc引入的，
1、目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降。即性能优化
2、作用：允许程序员将最有可能执行的分支告诉编译器。
3、指令的写法为：__builtin_expect(EXP, N)。表示 EXP==N的概率很大。
4、fastpath定义中__builtin_expect((x),1)表示 x 的值为真的可能性更大；即 执行if 里面语句的机会更大
5、slowpath定义中的__builtin_expect((x),0)表示 x 的值为假的可能性更大。即执行 else 里面语句的机会更大
6、在日常的开发中，也可以通过设置来优化编译器，达到性能优化的目的，设置的路径为：Build Setting --> Optimization Level --> Debug --> 将None 改为 fastest 或者 smallest

cls->ISA()->hasCustomAWZ()

其中fastpath中的 cls->ISA()->hasCustomAWZ() 表示判断一个类是否有自定义的 +allocWithZone 实现，这里通过断点调试，是没有自定义的实现，所以会执行到 if 里面的代码，即走到_objc_rootAllocWithZone

【第四步】跳转至_objc_rootAllocWithZone的源码实现

【第五步】跳转至_class_createInstanceFromZone的源码实现，这部分是alloc源码的核心操作，由下面的流程图及源码可知，该方法的实现主要分为三部分
cls->instanceSize：计算需要开辟的内存空间大小
calloc：申请内存，返回地址指针
obj->initInstanceIsa：将 类 与 isa 关联

根据源码分析，得出其实现流程图如下所示：

alloc 核心操作

核心操作都位于calloc方法中

cls->instanceSize：计算所需内存大小

计算需要开辟内存的大小的执行流程如下所示

• 1、跳转至instanceSize的源码实现

通过断点调试，会执行到cache.fastInstanceSize方法，快速计算内存大小

• 2、跳转至fastInstanceSize的源码实现，通过断点调试，会执行到align16

• 3、跳转至align16的源码实现，这个方法是16字节对齐算法

内存字节对齐原则

在解释为什么需要16字节对齐之前，首先需要了解内存字节对齐的原则，主要有以下三点

数据成员对齐规则：struct 或者 union 的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数据、结构体等）的整数倍开始（例如int在32位机中是4字节，则要从4的整数倍地址开始存储）
数据成员为结构体：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（例如：struct a里面存有struct b，b里面有char、int、double等元素，则b应该从8的整数倍开始存储）
结构体的整体对齐规则：结构体的总大小，即sizeof的结果，必须是其内部做大成员的整数倍，不足的要补齐
为什么需要16字节对齐

需要字节对齐的原因，有以下几点：

通常内存是由一个个字节组成的，cpu在存取数据时，并不是以字节为单位存储，而是以块为单位存取，块的大小为内存存取力度。频繁存取字节未对齐的数据，会极大降低cpu的性能，所以可以通过减少存取次数来降低cpu的开销
16字节对齐，是由于在一个对象中，第一个属性isa占8字节，当然一个对象肯定还有其他属性，当无属性时，会预留8字节，即16字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱
16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况
字节对齐-总结

在字节对齐算法中，对齐的主要是对象，而对象的本质则是一个 struct objc_object的结构体，
结构体在内存中是连续存放的，所以可以利用这点对结构体进行强转。
苹果早期是8字节对齐，现在是16字节对齐
下面以align（8） 为例，图解16字节对齐算法的计算过程，如下所示

首先将原始的内存 8 与 size_t(15)相加，得到 8 + 15 = 23
将 size_t(15) 即 15进行~（取反）操作，~（取反）的规则是：1变为0，0变为1
最后将 23 与 15的取反结果 进行 &（与）操作，&（与）的规则是：都是1为1，反之为0，最后的结果为 16，即内存的大小是以16的倍数增加的

calloc：申请内存，返回地址指针

通过instanceSize计算的内存大小，向内存中申请 大小 为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针

这里我们可以通过断点来印证上述的说法，在未执行calloc时，po obj为nil，执行后，再po obj法线，返回了一个16进制的地址

在平常的开发中，一般一个对象的打印的格式都是类似于这样的<LGPerson: 0x01111111f>（是一个指针）。为什么这里不是呢？

• 主要是因为objc 地址 还没有与传入 的 cls进行关联，
• 同时印证了 alloc的根本作用就是 开辟内存

经过calloc可知，内存已经申请好了，类也已经出入进来了，接下来就需要将 类与 地址指针 即isa指针进行关联，其关联的流程图如下所示

主要过程就是初始化一个isa指针，并将isa指针指向申请的内存地址，在将指针与cls类进行 关联

同样也可以通过断点调试来印证上面的说法，在执行完initInstanceIsa后，在通过po obj可以得出一个对象指针

总结

• 通过对alloc源码的分析，可以得知alloc的主要目的就是开辟内存，而且开辟的内存需要使用16字节对齐算法，现在开辟的内存的大小基本上都是16的整数倍
• 开辟内存的核心步骤有3步：计算 -- 申请 -- 关联

init 源码探索

alloc源码探索完了，接下来探索init源码，通过源码可知，inti的源码实现有以下两种

类方法 init

这里的init是一个构造方法 ，是通过工厂设计（工厂方法模式）,主要是用于给用户提供构造方法入口。这里能使用id强转的原因，主要还是因为 内存字节对齐后，可以使用类型强转为你所需的类型

实例方法 init

• 通过以下代码进行探索实例方法 init

• 通过main中的init跳转至init的源码实现

• 跳转至_objc_rootInit的源码实现

有上述代码可以，返回的是传入的self本身。

new 源码探索

一般在开发中，初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实一般在开发中，初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实现，通过源码可以得知，new函数中直接调用了callAlloc函数（即alloc中分析的函数），且调用了init函数，所以可以得出new 其实就等价于 [alloc init]的结论

但是一般开发中并不建议使用new，主要是因为有时会重写init方法做一些自定义的操作，例如 initWithXXX，会在这个方法中调用[super init]，用new初始化可能会无法走到自定义的initWithXXX部分。

例如，在CJLPerson中有两个初始化方法，一个是重写的父类的init，一个是自定义的initWithXXX方法，如下图所示

使用 alloc + init 初始化时，打印的情况如下

使用new 初始化时，打印的情况如下

总结

如果子类没有重写父类的init，new会调用父类的init方法
如果子类重写了父类的init，new会调用子类重写的init方法
如果使用 alloc + 自定义的init，可以帮助我们自定义初始化操作，例如传入一些子类所需参数等，最终也会走到父类的init，相比new而言，扩展性更好，更灵活。

补充

【问题】为什么无法断点到obj->initInstanceIsa(cls, hasCxxDtor);？

主要是因为断点断住的不是 自定义类的流程，而是系统级别的

作者：style_月月
链接：https://blog.csdn.net/lin1109221208/article/details/108427260

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

本文主要介绍下源码探索的三种方法

• 1、符号断点直接跟流程
• 2、通过按住control+step into
• 3、汇编跟流程

符号断点中输入 alloc

main中的CJLPerson处 加一个断点
在走到这部分断点之前，需要关闭上面新增的符号断点，原因是因为alloc的调用有很多，如果开启了就不能准确的定位到CJLPerson的alloc方法

以下为符号断点的关闭状态

运行程序, 断在CJLPerson部分

• 打开 alloc符号断点 ，断点状态为

  
  

  继续执行
  

  
  

  以下为alloc符号断点断住的堆栈调用情况，从下图可以看出 alloc 的源码位于libobjc.A.dylib库（需要去Apple 相应的开源网址下载 objc源码进行更深入的探索）
  

  
  

  2、通过按住control+step into

• main中的CJLPerson处 加一个断点，运行程序，会断在CJLPerson位置
• 
  
• 
  
• 按住 control键，选择 step into ⬇️键
  

进去后，显示为以下内容

再下一个objc_alloc符号断点，符号断点后显示了 objc_alloc所在的源码库
（需要去Apple 相应的开源网址下载 objc源码进行更深入的探索）

3、汇编跟流程

main中的CJLPerson处 加一个断点，运行程序，会断在CJLPerson位置

xcode 工具栏 选择 Debug --> Debug Workflow --> Always Show Disassembly,这个 选项表示 始终显示反汇编 ，即 通过汇编 跟流程

按住control，点击 step into ⬇️键，执行到下图的callq ，对应 objc_alloc

• 按住control，点击 step into ⬇️键进入，看到断点断在objc_alloc部分
  
• 
  
• 
  
• 同样通过objc_alloc的符号断点，得知源码所在库
  （需要去Apple 相应的开源网址下载 objc源码进行更深入的探索）
  
• 
  
• 
  

今晨，苹果正式宣布自 2022 年 6 月 30 日起，提交至 App Store 且支持账号创建的应用，必须允许用户在应用内删除账号。

6 月 30 日起，App 必须允许用户删除账号

从 2022 年 6 月 30 日开始，App Store 内支持账号创建的应用，必须提供删除账号的功能。

出海痛点很多？点击这里解决

开发者如需更新应用程序以完善删除账号功能，需要注意以下几点：

1）用户能在应用中快速找到删除账号的入口，一般可在账户设置中找到；

2）如果用户是通过 Apple ID 登录，需要在删除账号时使用 Sign in with Apple REST API 来撤销用户令牌；

3）用户删除账号不仅是暂时停用或禁用账号，苹果要求在应用内，所有与该账号相关的个人数据都可以被删除，以帮助用户更好地管理隐私数据；

4）受高度监管的应用可能需要提供额外的客户服务流程，以跟进账号删除过程；

5）遵守有关存储和保留用户账号信息以及处理账号删除的适用法律要求，包括遵守不同国家或地区的当地法律。

此外，如果用户需要访问网站以指引如何删除账号，开发者也需提供相关链接。

若删除账号需要额外的时间，或删除时应用购买问题需要另外解决，开发者也应告知用户。

App 删除账号功能相关问题

Q：开发者可以将用户引导到客户服务流程以完成账号删除吗？

A：受高度监管的应用，如中应用商店审查指南 5.1.1(ix)所述，可能会使用额外的客户服务流程来确认和促进账号删除过程。

不在高度监管的行业中运行的应用程序不应要求用户拨打电话、发送电子邮件或通过其他支持流程完成账号删除。

Q：开发者是否可以要求重新认证，或添加确认步骤以确保账号不会被意外删除或被账号持有人以外的人删除？

A：可以，确保删除动作是用户期望进行的。

开发者可以添加步骤来验证用户身份，并确认他们想要删除该账号（如通过输入已与该账号关联的电子邮件或电话号码）。

但是，给用户删除账号增加不必要的困难将不会通过审核。

Q：如应用使用 Sign in with Apple 为用户提供账号创建和身份验证，需要进行哪些更改？

A：支持 Sign in with Apple 的应用需要使用 Sign in with Apple REST API 来撤销用户令牌。更多信息，请查看苹果官方文档和设计建议。

Q：如果开发者的应用链接到默认网络浏览器以创建账号，是否仍需要在应用内提供账号删除功能？

A：是的。但请注意链接到默认 Web 浏览器进行登录或注册账号，会影响用户体验，具体可查看应用商店审查指南 4。

Q：应用会自动为用户创建一个账号，是否需要提供进行账号删除的选项？

A：是的。用户应该可以选择删除自动生成的账号（包括访客账号）以及与这些账号关联的数据。

同时，开发者需要确保应用中的任何账号创建都符合当地法律。

Q：账号删除是否必须立即自动完成？

A：不是，可以接受手动删除账号，并花费一些时间。

开发者需要通知用户删除账号需要多长时间，并在删除完成后提供确认，并确保删除账号所用的时间。

Q：删除账号后，用户产生的内容是否需要在共享的应用中删除？

A：是的。用户删除账号时，将删除与其账号关联的所有数据，包括与他人一起生成的内容，如照片、视频、文字帖子和评论等。

如果当地法律要求开发者维护某些数据，请另外告知用户。

Q：是否允许应用只在某些地方根据 CCPA、GDPR 或其他当地法律删除账号？

A：不可以。应该允许所有用户删除他们的账号，无论他们身在何处，开发者的账号删除流程也需要提供给所有用户。

Q：如何管理自动续订的用户，以免在用户删除账号后意外收费？

A：告知用户管理订阅，后续计费将通过 Apple 继续，并提醒用户在下一次收费前取消订阅。

开发者使用 App Store 自动续订的 Server Notifications，可以实时查看用户的订阅状态，或者使用订阅状态 API 进行识别。

同时，开发者可以提供 Apple 支持链接（https: //support.apple.com/en-us/HT204084），帮助用户提交退款请求。

此外，开发者还可以提供一个选项，即设置账号删除日期与订阅到期时间一致，但仍需提供可立即删除账号的选项。

应用更新过程中的更多常见问题，可访问以下网站了解：

https://developer.apple.com/support/offering-account-deletion-in-your-app

据悉，苹果去年就已宣布调整 App Store 的指导方针，要求应用允许用户删除自己的账户，但由于功能实现较复杂，苹果两度推迟实行。如今正式推行，预计未来一段时间内或将有大量应用进行更新。

KTV歌词解析, 音准评分组件

介绍

支持XML歌词解析, LRC歌词解析, 解决了多行歌词进度渲染的问题, 评分根据人声实时计算评分

欢迎各位大佬提交PR, 有问题提issue, 我会不定时fix

Github

使用方法

初始化

    private lazy var lrcScoreView: AgoraLrcScoreView = {
        let lrcScoreView = AgoraLrcScoreView(delegate: self)
        lrcScoreView.config.scoreConfig.scoreViewHeight = 100
        lrcScoreView.config.scoreConfig.emitterColors = [.systemPink]
        lrcScoreView.config.lrcConfig.lrcFontSize = .systemFont(ofSize: 15)
        return lrcScoreView
    }()

配置属性

组件base配置

    /// 评分组件配置
    public var scoreConfig: AgoraScoreItemConfigModel = .init()
    /// 歌词组件配置
    public var lrcConfig: AgoraLrcConfigModel = .init()
    /// 是否隐藏评分组件
    public var isHiddenScoreView: Bool = false
    /// 背景图
    public var backgroundImageView: UIImageView?
    /// 评分组件和歌词组件之间的间距 默认: 0
    public var spacing: CGFloat = 0

歌词配置

    /// 无歌词提示文案
    public var tipsString: String = "纯音乐，无歌词"
    /// 提示文字颜色
    public var tipsColor: UIColor = .black
    /// 提示文字大小
    public var tipsFont: UIFont = .systemFont(ofSize: 17)
    /// 分割线的颜色
    public var separatorLineColor: UIColor = .lightGray
    /// 是否隐藏分割线
    public var isHiddenSeparator: Bool = false
    /// 默认歌词背景色
    public var lrcNormalColor: UIColor = .gray
    /// 高亮歌词背景色
    public var lrcHighlightColor: UIColor = .white
    /// 实时绘制的歌词颜色
    public var lrcDrawingColor: UIColor = .orange
    /// 歌词文字大小 默认: 15
    public var lrcFontSize: UIFont = .systemFont(ofSize: 15)
    /// 歌词高亮文字缩放大小 默认: 1.1
    public var lrcHighlightScaleSize: Double = 1.1
    /// 歌词左右两边间距
    public var lrcLeftAndRightMargin: CGFloat = 15
    /// 等待开始圆点背景色 默认: 灰色
    public var waitingViewBgColor: UIColor? = .gray
    /// 等待开始圆点大小 默认: 10
    public var waitingViewSize: CGFloat = 10
    /// 是否可以拖动歌词 默认: true
    public var isDrag: Bool = true

评分配置

    /// 评分视图高度 默认:100
    public var scoreViewHeight: CGFloat = 100
    /// 圆的起始位置: 默认: 100
    public var innerMargin: CGFloat = 100
    /// 线的高度 默认:10
    public var lineHeight: CGFloat = 10
    /// 线的宽度 默认: 120
    public var lineWidht: CGFloat = 120
    /// 默认线的背景色
    public var normalColor: UIColor = .gray
    /// 匹配后线的背景色
    public var highlightColor: UIColor = .orange
    /// 分割线的颜色
    public var separatorLineColor: UIColor = .systemPink
    /// 是否隐藏垂直分割线
    public var isHiddenVerticalSeparatorLine: Bool = false
    /// 是否隐藏上下分割线
    public var isHiddenSeparatorLine: Bool = false
    /// 游标背景色
    public var cursorColor: UIColor = .systemPink
    /// 游标的宽
    public var cursorWidth: CGFloat = 20
    /// 游标的高
    public var cursorHeight: CGFloat = 20
    /// 是否隐藏粒子动画效果
    public var isHiddenEmitterView: Bool = false
    /// 使用图片创建粒子动画
    public var emitterImages: [UIImage]?
    /// emitterImages为空默认使用颜色创建粒子动画
    public var emitterColors: [UIColor] = [.red]
    /// 尾部动画图片
    public var tailAnimateImage: UIImage?
    /// 尾部动画颜色
    public var tailAnimateColor: UIColor? = .yellow
    /// 评分默认分数: 50
    public var defaultScore: Double = 50

事件回调

歌词Delegate

weak var delegate: AgoraLrcViewDelegate?
 
protocol AgoraLrcViewDelegate {
    /// 当前播放器的时间 单位: 秒
    func getPlayerCurrentTime() -> TimeInterval
    /// 获取歌曲总时长
    func getTotalTime() -> TimeInterval

    /// 设置播放器时间
    @objc
    optional func seekToTime(time: TimeInterval)
    /// 当前正在播放的歌词和进度
    @objc
    optional func currentPlayerLrc(lrc: String, progress: CGFloat)
}

歌词下载Delegate

weak var downloadDelegate: AgoraLrcDownloadDelegate?

protocol AgoraLrcDownloadDelegate {
    /// 开始下载
    @objc
    optional func beginDownloadLrc(url: String)
    /// 下载完成
    @objc
    optional func downloadLrcFinished(url: String)
    /// 下载进度
    @objc
    optional func downloadLrcProgress(url: String, progress: Double)
    /// 下载失败
    @objc
    optional func downloadLrcError(url: String, error: Error?)
    /// 下载取消
    @objc
    optional func downloadLrcCanceld(url: String)
    /// 开始解析歌词
    @objc
    optional func beginParseLrc()
    /// 解析歌词结束
    @objc
    optional func parseLrcFinished()
}

评分Delegate

weak var scoreDelegate: AgoraKaraokeScoreDelegate?

protocol AgoraKaraokeScoreDelegate {
    /// 分数实时回调
    /// score: 每次增加的分数
    /// cumulativeScore: 累加分数
    /// totalScore: 总分
    @objc optional func agoraKaraokeScore(score: Double, cumulativeScore: Double, totalScore: Double)
}

集成方式

本地pod引入,暂时使用本地pod 待后续发布cocoapods

把 'AgoraLrcScoreView' 复制到根目录, 执行pod

pod 'AgoraLrcScore', :path => "AgoraLrcScoreView"

作者：莫烦恼
来源：https://juejin.cn/post/7054443857928257550