Swift -- 13.Swift混编（下）

一.Swift中的framework

我们知道，在Swift项目中要想使用OC代码，必须要使用<projectName>-bridge-header.h。将OC桥接给Swift。

但是在framework中并没有xxx-bridge-header.h。那么framework是怎么管理的？

创建一个framework(Swift)，此时里面会有一个SwiftFramework.h文件。

SwiftFramework.h就相当于之前我们将的umbrella伞头文件。来管理我们的OC文件来暴露给Swift代码使用。

这也就是为什么framework(Swift)中没有xxx-bridge-header.h，那是因为我们在创建framework的时候默认创建了以framework名称的.h文件来暴露OC代码

编译framework查看modulemap

framework module SwiftFramework {
  umbrella header "SwiftFramework.h"

  export *
  module * { export * }
}

module SwiftFramework.Swift {
    header "SwiftFramework-Swift.h"
    requires objc
}

可以看到SwiftFramework.h就是一个伞头文件

1.案例理解Headers

这里我们创建了一个Swift的framework，添加了LGCat（OC文件），创建了一个LGTeacher(swift)

LGCat

//.h
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface LGCat : NSObject

- (void)speak;

@end

NS_ASSUME_NONNULL_END


//.m
#import "LGCat.h"

@implementation LGCat

-(void)speak {
    NSLog(@"LGCat speak");
}

@end

SwiftFramework.h

#import "LGCat.h"

那么此时，我们在LGTeacher内能否访问LGCat?

编译运行后会报错Include of non-modular header inside framework module 'SwiftFramework': '/Users/zt/Desktop/Swift混编/SwiftFramework/SwiftFramework/OBJC/LGCat.h'

这就是一个frameork开发的经典问题。此时的header权限有3种

Public暴露给外部，存在Headers目录下
Private暴露给外部，存在PrivateHeaders目录下。当我们把LGCat.h移动到这里后

PrivateHeaders

Project不暴露给外部。代表在编译的时候把头文件编译进去了。达到整个头文件隐藏的效果

那么我们继续分析，SwiftFramework.h中的umbrella header "SwiftFramework.h"中的header代码表的是什么？

代表的是framework中的Headers目录，因此这里将LGCat.h移动到Public，就能使用了。

此时又发现一个问题：为什么modulemap里设置的东西在Swift文件里能访问到？

2.重写modulemap

当我们在framework中重写modulemap时，默认生成的module文件就会被替换成重写的。

新建module.modulemap文件，新建Config.xcconfig文件，并配置到工程中

Config.xcconfig

MODULEMAP_FILE = ${SRCROOT}/SwiftFramework/module.modulemap

module.modulemap

framework module SwiftFramework {
    umbrella header "SwiftFramework.h"
    export *
    
    explicit module LGCat {
        header "LGCat.h"
        export *
    }
    
    module * {
        export *
    }
}

可以通过import SwiftFramework.LGCat来访问到LGCat

3.设置PrivateModule

需求：不想把LGCat暴露出去

创建一个private.module.modulemap,并且使它生效。对于的是MODULEMAP_PRIVATE_FILE

MODULEMAP_PRIVATE_FILE = ${SRCROOT}/SwiftFramework/module.private.modulemap

// 标准写法，xxx_Private
framework module SwiftFramework_Private {
    header "LGCat.h"
    export *
}

PrivateModule只针对外部工程，使用framework的工程。framework访问不到PrivateModule的。

外界可使用@import SwiftFramework_Private;来访问SwiftFramework_Private。

此时还是没有满足需求，接下来继续分析

问题：OC使用Swift代码，通过<projectName-Swift.h>将Swift代码翻译成OC代码，但是为什么只有声明，没有实现？

SWIFT_CLASS("_TtC14SwiftFramework9LGTeacher")
@interface LGTeacher : NSObject
- (nonnull instancetype)init SWIFT_UNAVAILABLE;
+ (nonnull instancetype)new SWIFT_UNAVAILABLE_MSG("-init is unavailable");
@end

通过@objc声明并且继承NSObject的类，在Swift编译的时候就会把它看成OC代码，编译的时候就会按照OC的方式进行编译，放到Mach-O（专门的segement和section）中。以便在运行的时候把class加载到内存中。

编译的时候就变成了OC符号，编译生成的.o的时候只需要头文件，link的过程中才需要符号的具有信息。所以说，Swift在和OC混编的时候，OC只需要Swift暴露出来的OC头文件就可以了。

此时我们是否可以通过这种思想来隐藏我们的LGCat

二.Swift&OC协议通讯

创建中间类

import Foundation

@objc(AnimalProtocol)
protocol Animal {
    init()
    func walk(withStep: Int)
}

//中间类
@objc(Zoo)
class Zoo : NSObject {
    private static var animal: Animal.Type!
    
    // OC把自己的类注册进来
    @objc static func registerAnimalType(type: Animal.Type) {
        animal = type
    }
    
    // Swift调用
    func creatAnimal() -> Animal {
        return Zoo.animal.init()
    }
}

/*
 SWIFT_PROTOCOL_NAMED("Animal")
 @protocol AnimalProtocol
 - (nonnull instancetype)init;
 - (void)walkWithStep:(NSInteger)withStep;
 @end

 SWIFT_CLASS_NAMED("Zoo")
 @interface Zoo : NSObject
 + (void)registerAnimalTypeWithType:(Class <AnimalProtocol> _Nonnull)type;
 - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
 @end
 */

创建SwiftToObjectiveC.h头文件来保存协议和Zoo对外暴露的接口（注意：查看暴露的内容需要加上public）。并且权限声明为project

在Swift类LGTeacher中，执行Animal协议的creatAnimal()及walk()

import Foundation

@objc
public class LGTeacher: NSObject {
    
    private let cat: Animal
    
    public override init() {
        cat = Zoo().creatAnimal()
    }
    
    @objc
    public func walk() {
        cat.walk(withStep: 10)
    }
}

在LGCat.m文件中注册类

//.h
#import <Foundation/Foundation.h>
#import "SwiftToObjectiveC.h"

NS_ASSUME_NONNULL_BEGIN

@interface LGCat : NSObject<AnimalProtocol>


@end

NS_ASSUME_NONNULL_END

//.m
#import "LGCat.h"

@implementation LGCat

+ (void)load {
    //OC的类注册进去
    [Zoo registerAnimalTypeWithType:[LGCat class]];
}

- (void)walkWithStep:(NSInteger)withStep {
    NSLog(@"Cat walk %ld", withStep);
}

@end

外界使用代码

#import <SwiftFramework/SwiftFramework-Swift.h>

LGTeacher *t = [LGTeacher new];
[t walk];

至此就完成了对LGCat的隐藏。个人感觉有点像类型擦除的概念，使用中间类隐藏了具体类的信息。这里就是相当于使用Zoo隐藏了Cat类型。

这样的好处：

SwiftToObjectiveC.h和LGCat.h没有被暴露出去
中间类Zoo对OC代码屏蔽了它的实现

总结3种方式：

如果不在乎头文件暴露的话，可以放到umbrella header里面或者modulemap里面。
如果想要提示一下用户，这些头文件不要使用，但是使用也没有关系的话，可以放到module.private.module里面。
如果一点也不想暴露的话，可以使用通过协议的方式把该屏蔽的屏蔽该暴露的暴露。

简单分析：OC头文件编译的过程？

.swift/.m代码通过.h文件生成.o文件。头文件都是一些声明，生成.o的过程中，它不知道这些声明代表的函数体到底是什么。所以在生成.o的时候有一个符号表保存着不知道函数体，只有符号名称的符号，叫做重定位符号表。等link的时候通过重定位符号表去找这个符号所代表的含义（函数体、具体内容是什么）。

这里的LGCat.h是在LGCat.m编译成.o的时候使用。ObjectiveCToSwift.swift也会通过SwiftToObjectiveC.h编译成.o。在link的时候2个正好合在一起了，LGCat的.o保存着ObjectiveCToSwift的头文件，ObjectiveCToSwift的.o保存着头文件具体的实现。

三.多SwiftModule引入

1.多个静态库合并

创建2个framework(Static),保存至Muti.workspace。添加脚本

//将framework保存到Products目录下
cp -Rv -- "${BUILT_PRODUCTS_DIR}/" "${SOURCE_ROOT}/../Products"

设置编译A时同时编译B，编译后，得到2个framework

❯ cd /Users/zt/Desktop/Swift混编/多module合并/Products
❯ libtool -static -o libAB.a /Users/zt/Desktop/Swift混编/多module合并/Products/SwiftA.framework/SwiftA /Users/zt/Desktop/Swift混编/多module合并/Products/SwiftB.framework/SwiftB

此时得到了合并后的静态库libAB.a，此时的静态没有了modulemap、Headers，暂时也不能使用

2.配置合并后的静态库

创建一个xcconfig，并与项目产生关联

//导入原有2个framework的modulemap文件
OTHER_CFLAGS = "-fmodule-map-file=${SRCROOT}/SwiftA.framework/Modules/module.modulemap" "-fmodule-map-file=${SRCROOT}/SwiftB.framework/Modules/module.modulemap"

//设置framework搜索路径
FRAMEWORK_SEARCH_PATHS = ${SRCROOT}

使用原有的module.modulemap

3.ViewController中验证是否能够使用合并后的libAB.a

@import SwiftA;
@import SwiftB;

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    SwiftATeacher *a = [SwiftATeacher new];
    [a speak];
    
    SwiftBTeacher *b = [SwiftBTeacher new];
    [b speak];
}

此时OC代码是可以正常的使用Swift库的
此时的Swift代码也是可以通过import SwiftA来正常使用Swift库

4.OC通过头文件来调用Swift

创建一个public文件夹，来存放2个framework的头文件

xcconfig中设置Header搜索路径

HEADER_SEARCH_PATHS = ${SRCROOT}/Pods/Public

此时去验证的话，也是能够使用的。

#import <SwiftA-Swift.h>
#import <SwiftB-Swift.h>


@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    SwiftATeacher *a = [SwiftATeacher new];
    [a speak];

    SwiftBTeacher *b = [SwiftBTeacher new];
    [b speak];
    
//    SwiftCTeacher *c = [SwiftCTeacher new];
//    [c speaks];
}

因为此时是通过头文件去访问的，并且设置了头文件的搜索路径。此时就能够使用头文件里暴露出的函数。OC使用Swift只需要头文件就可以了。