iOS OS X平台文档

集成说明

1. 下载源码到本地
2. 打开Release目录，如果您的是OC项目，可根据需要运行系统选择iOS或者OSX目录；如果您的是Swift项目，则可以根据运行系统选择iOS-Swift或者OSX-Swift目录
3. 直接拖动目录到XCode的工程下进行导入，导入时记得勾选"Copy items if needed"。
4. 导入成功后则可以正常使用LuaScriptCore了。

关于重新编译的问题

本项目提供的库是基于XCode 8.0进行编译的，如果想要要低于XCode 8.0上能够成功编译，需要进行库的重新编译，请根据下面的步骤实现：

1. 打开Source/iOS_OSX/目录中的LuaScriptCore项目文件。
2. 选择你想要重新编译的平台，如果是iOS的OC版本则选择LuaScriptCore-iOS-output的scheme，Swift版本则选择LuaScriptCore-iOS-Swift-output的scheme；如果是OS X的OC版本则选择LuaScriptCore-OSX-output的scheme，Swift版本则选择LuaScriptCore-OSX-Swift-output的scheme。
3. Command + B 进行重新编译，编译后的库文件和头文件会放到Release目录下替换原有的文件。

使用说明

初始化LuaScriptCore

LuaScriptCore中提供了LSCContext（Swift中为LuaContext）这个上下文对象类来维护整个Lua的环境，所以使用LuaScriptCore的第一步就是对Context进行初始化。如：

Objective-C中

LSCContext *context = [[LSCContext alloc] init];

Swift中

var _context : LuaContext = LuaContext();

初始化完毕后才能进行下面的各种操作。

解析Lua脚本

原生层中要操作Lua中的变量或者方法，通常使用到的就是组织Lua脚本来进行一些列的Lua操作（LuaScriptCore屏蔽了Lua库中的C Api，目的是让代码更加接近原生，使用起来更加得心应手），然后交由Context进行脚本的解析。如：

Objective-C中

[self.context evalScriptFromString:@"print('Hello World');"];

Swift中

_context.evalScript(script: "print('Hello World');");

注册一个原生方法给Lua调用

对于一些耗时或者Lua无法实现的功能（如：手机设备的拍照），都可以考虑交由原生层来实现，然后提供接口让Lua进行调用。如下面获取手机设备信息的方法：

如果是Objective-C项目，在Objective-C代码中定义方法

[self.context registerMethodWithName:@"getDeviceInfo" block:^LSCValue *(NSArray *arguments) {

    NSMutableDictionary *info = [NSMutableDictionary dictionary];
    [info setObject:[UIDevice currentDevice].name forKey:@"deviceName"];
    [info setObject:[UIDevice currentDevice].model forKey:@"deviceModel"];
    [info setObject:[UIDevice currentDevice].systemName forKey:@"systemName"];
    [info setObject:[UIDevice currentDevice].systemVersion forKey:@"systemVersion"];

    return [LSCValue dictionaryValue:info];

}];

如果是Swifit项目，则在Swifit代码中定义方法

_context.registerMethod(methodName: "getDeviceInfo", block: { (arguments : Array<LuaValue>) -> LuaValue in

    var info : Dictionary<String, String> = Dictionary<String, String>();
    info["deviceName"] = UIDevice.current.name;
    info["deviceModel"] = UIDevice.current.model;
    info["systemName"] = UIDevice.current.systemName;
    info["systemVersion"] = UIDevice.current.systemVersion;

    return LuaValue(dictionaryValue: info);

});

在Lua代码中调用方法

local tbl = getDeviceInfo();

调用一个Lua方法

有时候需要通过调用Lua中的方法来取得返回值（在原生层中只能取得一个返回值），然后再做后续的处理，例如：

在Lua代码中有add方法的定义

function add (a, b)

    return a+b;

end

如果是Objective-C项目，在Objective-C代码中通过context调用Lua方法

LSCValue *value = [self.context callMethodWithName:@"add"
                                         arguments:@[[LSCValue integerValue:1000],
                                                     [LSCValue integerValue:24]]];
NSLog(@"result = %@", [value toNumber]);

如果是Swift项目，在Swift代码中通过context调用Lua方法

let retValue : LuaValue? = _context.callMethod(methodName: "add", 
                                               arguments: [LuaValue(intValue: 1000), LuaValue(intValue:24)]);
if (retValue != nil)
{
    NSLog("result = %d", retValue!.intValue);
}

模块化扩展

LSCContext(Swift中为LuaContext)所定义的方法都是全局的，有时候需要对一系列的方法进行一个包装，希望这些方法都归类在某个模块下，一来方便根据模块来划分方法的功能，二来可以避免名称的冲突。因此，可以使用LSCModule来对Lua的功能进行扩展。需要根据下面步骤实现：

1. 新声明一个模块类继承于LSCModule类（必须继承于LSCModule类，否则无法进行模块注册）
2. 在创建的模块类中定义需要导出到lua的类方法(即＋号方法，注：－号方法是不会进行导出)，声明方法完全跟Objective-C/Swift的方法一样（对于不想导出到Lua的方法可以在定义是使用下划线“_”开头），但需要注意的是结构体是无法作为参数或者返回值与Lua进行交互。
3. 调用LSContext的registerModuleWithClass方法(Swift中调用LuaContext的registerModule方法)将定义的类型传入即完成功能模块的扩展。

下面例子定义了一个日志模块，如：

在Objective-C代码中定义LSCModule的子类

/**
 *  日志模块
 */
@interface LogModule : LSCModule

/**
 *  写入日志
 *
 *  @param message 日志信息
 */
+ (void)writeLog:(NSString *)message;

@end

@implementation LogModule

+ (void)writeLog:(NSString *)message
{
    NSLog(@"** message = %@", message);
}

@end

注册模块

[self.context registerModuleWithClass:[LogModule class]];

如果你的是Swift项目，则可以在Swift代码中进行如下定义

class LogModule: LSCModule
{
    static func writeLog(message : String) -> Void
    {
        NSLog("** message = %@", message);
    }
}

然后注册模块

_context.registerModule(moduleClass: LogModule.self);

在Lua代码中调用

LogModule.writeLog('Hello Lua Module!');

让Lua面向对象

Lua中没有明确的面向对象特性，LuaScriptCore提供了一个面向对象的扩展，Lua可以简单地封装类型，并且进行类型实例的使用。首先需要先注册面向对象的模块类LSCObjectClass（如果原生层有继承于LSCObjectClass类的子类需要注册时，该步骤可省略），如：

Objective-C中

[self.context registerModuleWithClass:[LSCObjectClass class]];

Swift中

_context.registerModule(moduleClass: LSCObjectClass.self);

注册成功后，可以直接在Lua中定义类型，如：

Object.subclass("MyClass");

-- 重写类型的初始化方法
function MyClass:init ()
    print("MyClass instance initialize...");
end

-- 定义类型属性
MyClass.property = 0;

local instance = MyClass.create();
print (instance.property);

上述代码的subclass就是子类化对象方法，其接收一个类型名称参数，调用后会创建一个对应名称的类型。该类型拥有Object的所有特性。

对于Lua的类定义有如下设定：

1. 所有类型的根类是Object，这个注册LSCObjectClass后会有这个类的定义.
2. 必须使用subclass方法来进行子类化，必须传入一个有效并且不重复的类型名称参数。
3. 必须使用类型的create方法进行类对象的实例化。
4. 类型中的方法（即类方法）都以.号进行调用，类实例中的方法都以:号进行调用。类型和实例的属性都以.号进行访问。
5. 每个类中都有一个叫super的属性来指代其父类型。
6. 需要调用父类方法时，请使用"类型.super.method"方式进行调用，如：MyClass.super.test();。
7. 当类实例对象初始化时会触发init方法，销毁时会触发destroy方法，可以通过重写这些方法来进行一些额外的工作。

如果需要让原生类直接映射到Lua中，按照下面步骤实现：

1. 定义一个新的类继承于LSCObjectClass类。
2. 定义新类型的属性和方法（注：原生类中的属性会转换为Lua类中的setXXX和XXX方法），对于不想导出到Lua中的方法或属性可以在声明时使用下划线“_”开头。
3. 定义类的类方法会导出给类型，定义实例方法会导出给类型的实例。
4. 调用LSContext的registerModuleWithClass方法(Swift中调用LuaContext的registerModule方法)将定义的类型传入即完成Lua类的声明。导入时可以直接导入子类，LSContext（或LuaContext）会检测是否有导入根类型。

如在OC中有如下类型定义

@interface LSCTPerson : LSCObjectClass

@property (nonatomic, copy) NSString *name;

+ (NSString *)moduleName;

+ (void)printPersonName:(LSCTPerson *)person;

- (void)speak;

- (void)walk;

@end

@implementation LSCTPerson

+ (NSString *)moduleName
{
    //变更导出的类型名称
    return @"Person";
}

+ (void)printPersonName:(LSCTPerson *)person
{
    NSLog(@"Person name = %@", person.name);
}

- (void)speak
{
    NSLog(@"%@ speak", self.name);
}

- (void)walk
{
    NSLog(@"%@ walk", self.name);
}

@end

然后对该类型进行注册：

[self.context registerModuleWithClass:[LSCTPerson class]];

在Swift中可以如下定义

class LSCTPerson: LSCObjectClass
{
    static override func moduleName() -> String
    {
        return "Person";
    }

    static func printPersonName(p : LSCTPerson) -> Void
    {
        NSLog("%@", p.name);
    }

    var name : String? = nil;

    func speak() -> Void
    {
        NSLog("%@ speak", name ?? "noname");
    }

    func walk() -> Void
    {
        NSLog("%@ walk", name ?? "noname");
    }
}

然后对该类型进行注册：

_context.registerModule(moduleClass: LSCTPerson.self);

注册成功后，在lua中即可使用该类型：

local person = Person.create();
person:setName("vimfung");
person:walk();
person:speak();
Person.printPersonName(person);