記Android層執行Lua腳本的一次實踐

時間  2019-11-17
標籤 android 執行 lua 腳本 一次 實踐 欄目 Android 简体版
原文   原文鏈接

0. 前言

    最近一直在寫Lua腳本，有時候出了問題，不知道是Lua層的問題，仍是上游的問題，不知道從何下手。因而我學習了一點C/C++和JNI，把執行Lua腳本的流程的邏輯通讀了一遍。通讀一遍以後，就萌生了本身實現一個Android跑Lua腳本的想法。因而就有這篇博文。C/C++和Kotlin我都不熟，因此此次我主要用這兩種語言來寫（因此會很Java Style）。html

1. 環境搭建

    首先如今Lua官網下載Lua的源碼，我用的是5.3.5版本的。而後把源碼導入到Project中，寫好CMakeList：java

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.
add_definitions(-Wno-deprecated)

add_library( # Sets the name of the library.
        luabridge

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        src/main/jni/lua/lapi.c
        src/main/jni/lua/lauxlib.c
        src/main/jni/lua/lbaselib.c
        src/main/jni/lua/lbitlib.c
        src/main/jni/lua/lcode.c
        src/main/jni/lua/lcorolib.c
        src/main/jni/lua/lctype.c
        src/main/jni/lua/ldblib.c
        src/main/jni/lua/ldebug.c
        src/main/jni/lua/ldo.c
        src/main/jni/lua/ldump.c
        src/main/jni/lua/lfunc.c
        src/main/jni/lua/lgc.c
        src/main/jni/lua/linit.c
        src/main/jni/lua/liolib.c
        src/main/jni/lua/llex.c
        src/main/jni/lua/lmathlib.c
        src/main/jni/lua/lmem.c
        src/main/jni/lua/loadlib.c
        src/main/jni/lua/lobject.c
        src/main/jni/lua/lopcodes.c
        src/main/jni/lua/loslib.c
        src/main/jni/lua/lparser.c
        src/main/jni/lua/lstate.c
        src/main/jni/lua/lstring.c
        src/main/jni/lua/lstrlib.c
        src/main/jni/lua/ltable.c
        src/main/jni/lua/ltablib.c
        src/main/jni/lua/ltm.c
        src/main/jni/lua/lua.c
        #src/main/jni/lua/luac.c
        src/main/jni/lua/lundump.c
        src/main/jni/lua/lutf8lib.c
        src/main/jni/lua/lvm.c
        src/main/jni/lua/lzio.c)

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
        log-lib

        # Specifies the name of the NDK library that
        # you want CMake to locate.
        log)

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
        luabridge

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib})
複製代碼

    我要跑是 *.lua 類型的腳本，那就留下lua.c並刪掉luac.c，CMakeList裏面也要跟着註釋掉。另外，由於我把Lua的源代碼導入進來當作一個庫，因此也不須要main方法了，把lua.c裏面的main方法註釋掉。最後Rebuild一下Project就能夠了。android

2. Android單向調用Lua

    先定一個小目標，Android層調用Lua層的函數，Lua層作一個加法後把結果返回給Android層。先寫好Lua腳本：git

function test(a, b)
	return a + b
end
複製代碼

    這個Lua腳本很簡單，把傳過來的a和b相加後返回。如今咱們能夠開始考慮Native層的實現。在考慮實現以前，須要瞭解Lua虛擬棧和幾個Lua C API。github

2.1. Lua虛擬棧

    Lua層和Native層的數據交換是經過Lua虛擬棧來完成的。這個虛擬棧和普通的棧略有不一樣，它能夠經過負值索引來訪問指定元素。如圖：shell

Lua虛擬棧
    和普通的棧同樣，Lua虛擬棧一樣遵循先進後出原則，索引從下往上增長。不一樣的是Lua虛擬棧支持負值索引，使用負值索引能夠自棧頂向下索引。

2.2. Lua C APIs

    Lua提供了C APIs，方便Native層和Lua層之間的通信。下面的Demo會用到這幾個C API。編程

  • lua_State *luaL_newstate (void);api

    新建一個Lua的context。安全

  • int luaL_loadbuffer (lua_State *L, const char *buff, size_t sz, const char *name);bash

    編譯一個Lua chunk。若是編譯成功，它會把編譯結果包裝成一個函數，並把這個函數推入到棧中；不然，編譯失敗，它會把錯誤信息推入棧中。

    參數 類型 說明
    L lua_State* Lua的context
    buff const char* 須要加載的Lua腳本buffer
    sz size_t Lua腳本buffer的長度
    name const char* 這個chunk的名稱，可空

  • int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);

    以安全模式調用一個函數，即便拋出異常也不會崩潰。當拋出異常時，若是errfunc爲0，Lua虛擬機會把錯誤信息推入到Lua虛擬棧中，若是errfunc不爲0，則錯誤處理會交由Lua虛擬棧中索引爲errfunc的函數處理。執行結束後，Lua虛擬機會把參數以及調用的函數從棧中彈出。

    參數 類型 說明
    L lua_State* Lua的context
    nargs int 須要調用的函數的參數個數
    nresults int 須要調用的函數的返回結果個數
    errfunc int 錯誤處理函數在Lua虛擬棧中的索引，若是爲0，錯誤信息會推入到Lua虛擬棧中

  • void lua_getglobal (lua_State *L, const char *name);

    獲取名字爲name的全局變量，並推入棧中。

    參數 類型 說明
    L lua_State* Lua的context
    name const char* 變量名稱

  • void lua_pushinteger (lua_State *L, lua_Integer n);

  • 推入一個lua_Integer類型的數據到棧中

    參數 類型 說明
    L lua_State* Lua的context
    n lua_Integer 須要推入的數字

  • lua_Integer lua_tointeger (lua_State *L, int index);

    將棧中的索引爲index的元素轉lua_Integer並返回

    參數 類型 說明
    L lua_State* Lua的context
    index int 指定元素在棧中的索引

    除了這些C API，其餘的介紹及其用法能夠查看官網的說明。

    經過理解Lua虛擬棧和了解一些Lua C API，咱們就能夠實現一個簡單的Native層調用Lua層函數的功能。

jint startScript(JNIEnv* env, jobject obj, jstring jLuaStr, jint a, jint b) {
	// 建立一個lua context
	lua_State* luaContext = lua_newstate();
	// 初始化lua lib
	luaL_openlibs(luaContext);
	const char* cLuaStr = env->GetStringUTFChars(jLuaStr, NULL);
	
	// 加載buff到內存
	int loadStatus = luaL_loadbuffer(luaContext, cLuaStr, strlen(cLuaStr), NULL);
	if (LUA_OK != loadStatus) {
        const char *szError = luaL_checkstring(luaContext, -1);
        Log_e(LOG_TAG, "%s", szError);
        return -1;
    }
	env->ReleaseStringUTFChars(jLuaStr, cLuaStr);
	int callStatus = lua_pcall(luaContext, 0, LUA_MULTRET, 0);
    if (LUA_OK != callStatus) {
        const char *szError = luaL_checkstring(luaContext, -1);
        Log_e(LOG_TAG, "%s", szError);
        return -1;
    }
	
	// 獲取test方法
	lua_getglobal(luaContext, "test");
    if (LUA_TFUNCTION != lua_type(luaContext, -1)) {
        Log_d(LOG_TAG, "can not found func : %s", "test");
        return false;
    }
	
	// 推入參數
	lua_pushinteger(luaContext, a);
	lua_pushinteger(luaContext, b);
	
	// 執行test方法
	int callTestStatus = lua_pcall(luaContext, 2, 1, 0);
	if(LUA_OK == callTestStatus) {
		int ret = lua_tointeger(luaContext, 1)
		return ret;
	} else {
		const char* errMsg = lua_tostring(luaContext, 1)
		Log_e(LOG_TAG, "%s", errMsg);
		return -1;
	}
}
複製代碼

    流程如註釋。在這一個過程當中，Lua虛擬棧的內容變化如圖，從luaL_loadbuffer開始：

Lua虛擬棧內容變化

    首先，通過luaL_loadbuffer以後，luaL_loadbuffer會把傳過來的*.lua文件的buffer做爲一個Lua Chunk，接着編譯它。編譯完後，把編譯結果包裝成一個function並推入Lua虛擬棧中。通過lua_pcall後，Lua虛擬機會把所執行的function及其參數從Lua虛擬棧中彈出。接着，經過lua_getglobal獲取Lua層的全局變量「test」，lua_getglobal會把這個變量的值推入Lua虛擬棧中。函數已經準備好，再通過lua_pushinteger(a)和lua_pushinteger(b)後，函數和參數都已經順序推入了，調用lua_pcall的先決條件已經知足。接下來，調用lua_pcall後，Lua虛擬機會根據調用lua_pcall是傳入的nresults，將結果推入Lua虛擬棧中。最後，咱們只須要lua_tointeger(index)來獲取執行結果，返回給Android層便可。能夠看到，自始至終，Lua虛擬棧充當一個數據交換的橋樑，是一個十分重要的角色。

    接下來，只須要在Native層Register一下NativeMethods，並在Android層聲明一下native方法就可使用了。

class LuaExecutor {
    init {
        System.loadLibrary("luabridge")
    }

    external fun startScript(luaString: String): Boolean
}
複製代碼

    然而，上面的實現只有啓動腳本的功能。在實際中，咱們總不可能啓動腳本以後，就沒有對腳本執行流程有一點控制吧。所以有必要加一箇中止腳本的功能。如何中止正在執行的腳本？先來看看Lua提供的C API：

  • int luaL_error (lua_State *L, const char *fmt, ...);

    拋出一個異常，錯誤信息爲fmt。

    參數 類型 說明
    L lua_State* Lua的context
    fmt const char* 錯誤信息

  • int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);

    設置一個鉤子函數。

    參數 類型 說明
    L lua_State* Lua的context
    f lua_Hook 鉤子函數，包含須要執行的語句
    mask int 指定被調用的時機，取值爲常量LUA_MASKCALL，LUA_MASKRET，LUA_MASKLINE和LUA_MASKCOUNT的按位或。
    mask取值 說明
    LUA_MASKCALL 表明鉤子函數f會在進入任意函數後執行
    LUA_MASKRET 表明鉤子函數在退出任意函數前執行
    LUA_MASKLINE 表明鉤子函數f會在執行函數內一行代碼前執行
    LUA_MASKCOUNT 表明鉤子函數f會在lua解釋器執行了count條指令後執行

    有了這兩個C API，腳本的中止功能就能夠實現了：

void stopLuaHooker(lua_State *L, lua_Debug *ar) {
    luaL_error(L, "quit Lua");
}

void forceStopLua(lua_State *L) {
    int mask = LUA_MASKCOUNT;
    lua_sethook(L, &stopLuaHooker, mask, 1);
}
複製代碼

    當咱們調用forceStopLua時，會爲Lua腳本的執行設置一個鉤子函數，這個鉤子函數的執行時機是：lua_sethook執行以後，Lua解釋器執行完一條指令時。也就是說，咱們在Lua層代碼執行到任意地方時調用forceStopLua後，Lua解釋器會在執行完一條指令後，接着執行stopLuaHooker，進而執行lua_error，拋出異常，腳本即終止。所以，腳本的啓動和中止的功能已經實現好了，封到一個類裏，叫作LuaEngine：

#ifndef ANDROIDLUA_LUAENGINE_H
#define ANDROIDLUA_LUAENGINE_H

#include <cstring>
#include <string>
#include <jni.h>
#include "lua/lua.hpp"

#include "utils/Log.h"
#include "JniManager.h"

#define LOG_TAG "LuaEngine"

class LuaEngine {
public:
    LuaEngine();

    virtual ~LuaEngine();

    lua_State *getScriptContext() {
        return mScriptContext;
    }

    bool startScript(jstring jBuff, const char *functionName);

    bool isScriptRunning() {
        return scriptRunning;
    }

    bool stopScript();

private:
    lua_State *mScriptContext;
    bool scriptRunning;

    bool loadBuff(jstring jBuff);

    bool runLuaFunction(const char *functionName);
};

void quitLuaThread(lua_State *L);

void quitLuaThreadHooker(lua_State *L, lua_Debug *ar);

#endif //ANDROIDLUA_LUAENGINE_H
複製代碼
#include "LuaEngine.h"

LuaEngine::LuaEngine() {
    mScriptContext = luaL_newstate();
    scriptRunning = false;
}

LuaEngine::~LuaEngine() {
    if (isScriptRunning()) {
        stopScript();
    }
    mScriptContext = nullptr;
}

bool LuaEngine::startScript(jstring jBuff, const char *functionName) {
    scriptRunning = true;
    luaL_openlibs(mScriptContext);
    if (this->loadBuff(jBuff)) {
        Log_d(LOG_TAG, "script start running..");
        bool success = this->runLuaFunction(functionName);
        scriptRunning = false;
        return success;
    } else {
        scriptRunning = false;
        return false;
    }
}

bool LuaEngine::stopScript() {
    if (scriptRunning) {
        quitLuaThread(mScriptContext);
        scriptRunning = false;
        return true;
    } else {
        Log_d(LOG_TAG, "script is Not running");
        return false;
    }
}

bool LuaEngine::loadBuff(jstring jBuff) {
    // 讀取buff
    JNIEnv *env;
    JniManager::getInstance()->getJvm()->GetEnv((void **) &env, JNI_VERSION_1_6);
    const char *cBuff = env->GetStringUTFChars(jBuff, nullptr);
    if (LUA_OK != luaL_loadbuffer(mScriptContext, cBuff, strlen(cBuff), NULL)) {
        const char *szError = luaL_checkstring(mScriptContext, -1);
        Log_e(LOG_TAG, "%s", szError);
        return false;
    }
    // 加載buff到內存
    if (LUA_OK != lua_pcall(mScriptContext, 0, LUA_MULTRET, 0)) {
        const char *szError = luaL_checkstring(mScriptContext, -1);
        Log_e(LOG_TAG, "%s", szError);
        return false;
    }
    env->ReleaseStringUTFChars(jBuff, cBuff);
    env->DeleteGlobalRef(jBuff);
    return true;
}

bool LuaEngine::runLuaFunction(const char *functionName) {
    // 獲取errorFunc
	// 錯誤由__TRACKBACK__來處理，能夠用來打印錯誤信息，
	// __TRACKBACK__函數須要本身定義在lua腳本中
    lua_getglobal(mScriptContext, "__TRACKBACK__");
    if (lua_type(mScriptContext, -1) != LUA_TFUNCTION) {
        Log_d(LOG_TAG, "can not found errorFunc : __TRACKBACK__");
        return false;
    }
    int errfunc = lua_gettop(mScriptContext);

    // 獲取指定的方法
    lua_getglobal(mScriptContext, functionName);
    if (lua_type(mScriptContext, -1) != LUA_TFUNCTION) {
        Log_d(LOG_TAG, "can not found func : %s", functionName);
        return false;
    }

    // 跑指定的方法
    return LUA_OK == lua_pcall(mScriptContext, 0, 0, errfunc);
}

void quitLuaThread(lua_State *L) {
    int mask = LUA_MASKCOUNT;
    lua_sethook(L, &quitLuaThreadHooker, mask, 1);
}

void quitLuaThreadHooker(lua_State *L, lua_Debug *ar) {
    luaL_error(L, "quit Lua");
}
複製代碼

3. Lua單向調用Android

    前面的實現，只容許Android層調用Lua的方法，而Lua層並不能調用Android層的方法。可不能夠在Lua層調用Android層的方法？答案是能夠的。一個思路是，Lua層調用Native層的方法，Native層再經過反射調用Android層的方法。先看看Lua層是怎麼調用Native層的方法。Lua提供了一個C API：lua_register，它的原型是：

  • void lua_register (lua_State *L, const char *name, lua_CFunction f);

    註冊一個CFunction。

    參數 類型 說明
    L lua_State* Lua的context
    name const char* Lua層全局變量的名稱
    f lua_CFunction C函數。原型是：int functionXXX(lua_State* L);其返回值的意義表明返回結果的個數。

    咱們能夠用這個C API實現Lua層調用Native層的方法：

lua_register(mScriptContext, "getString" , getString);

int getString(lua_State *L) {
    const char *cStr = "String From C Layer";
    lua_pushstring(L, cStr);
    return 1;
}
複製代碼

    上面的代碼很簡單，先註冊一個名字爲getString的全局變量，指向C函數getString。C函數getString中，先聲明並分配一個字符串cStr，再把這個字符串推入到Lua棧中，並返回結果個數。所以，在Lua層，若是執行getString()，則會獲得字符串"String From C Layer"，Lua層就能夠調用Native層的方法了。

    而後看看Native層調用Android層的方法。代碼以下：

int getString(lua_State *L) {
	JNIEnv* env;
	g_pJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
	
    jclass clazz = env->FindClass("com/zspirytus/androidlua/shell/ShellBridge");
	if (!clazz) {
        Log_d(LOG_TAG, "class not found!");
        return 0;
    }
	
    jmethodID methodId = env->GetStaticMethodID(clazz, "getStringFromKotlinLayer", "()Ljava/lang/String;");
    if (!methodId) {
        Log_d(LOG_TAG, "method %s not found!", "getStringFromStaticJavaMethod");
        return 0;
    }
	
    jstring jStr = (jstring) env->CallStaticObjectMethod(clazz, methodId);
	
    const char *cStr = env->GetStringUTFChars(jStr, NULL);
    lua_pushstring(L, cStr);
    env->ReleaseStringUTFChars(jStr, cStr);
    env->DeleteLocalRef(jStr);
    return 1;
}
複製代碼

    解釋一下，首先經過在JNI_OnLoad保存下來的JavaVM指針指針得到Jni的環境變量，再用Jni的環境變量找到class和method，最後經過env、class和method反射調用Android層的方法得到返回的jstring，轉成C-style的string後推入lua棧中，釋放資源，並返回結果個數。

    在Android層，留下一個方法以供調用：

@Keep
object ShellBridge {

    private val TAG = ShellBridge.javaClass.simpleName

    @Keep
    @JvmStatic
    fun getStringFromKotlinLayer(): String {
        return "String From Android Layer"
    }
}
複製代碼

    至此，Android層與Lua層的交互已經實現了。

4. 避免ANR

    然而上面的實現可能會致使ANR，緣由在於Lua腳本的執行多是耗時的。若是Lua腳本的執行時間超過5秒，必然ANR。一個解決方法是，把Lua腳本的執行放到子線程當中。這個子線程應當給Native層管理比較好，仍是Android層管理比較好？我我的以爲放在Native層比較好，這樣Android層就不須要專爲執行Lua腳本而新建和管理線程，代碼就不會太複雜；即便Native層的邏輯比較複雜，編好了so，通常就會當作一個庫來使用，而不會去動它。因此，仍是在Native層建立和管理線程。 pthread_create是Unix、Linux等系統建立線程的函數，它的原型是：

  • int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

    參數 類型 說明
    tidp pthread_t *restrict 線程ID
    attr const pthread_attr_t*restrict 線程屬性，默認爲NULL
    *(*start_rtn)(void *) void 運行在新線程的函數
    *restrict arg void start_rtn的所需參數

    所以，咱們能夠把執行Lua腳本的邏輯移到新線程中：

void startWork() {
    pthread_create(&mThreadId, NULL, &startWorkInner, (void*)this);
}

void stopWork() {
    stopScript();
    mThreadId = 0;
}

void* startWorkInner(void *args) {
    startScript();
    return nullptr;
}
複製代碼

    這樣，startScript()就運行在新線程中，就不會有ANR的風險。咱們把它封到一個類中，叫LuaTask，一次Lua腳本的開始與結束，都由這個類來管理。

#ifndef ANDROIDLUA_LUATASK_H
#define ANDROIDLUA_LUATASK_H

#include <sys/types.h>
#include <pthread.h>
#include <jni.h>

#include "LuaEngine.h"

class LuaTask {

public:
    LuaTask(jstring jBuff);

    virtual ~LuaTask();

    void startWork();

    void stopWork();

    bool isRunning();

private:
    static void *startWorkInner(void *args);

private:
    jstring mLuaBuff;
    pthread_t mThreadId;
    LuaEngine *mLuaEngine;
};

#endif //ANDROIDLUA_LUATASK_H
複製代碼
#include "LuaTask.h"

LuaTask::LuaTask(jstring jBuff) {
    mLuaBuff = jBuff;
    mLuaEngine = new LuaEngine();
    mThreadId = 0;
}

LuaTask::~LuaTask() {
    delete mLuaEngine;
}

void LuaTask::startWork() {
    pthread_create(&mThreadId, NULL, &LuaTask::startWorkInner, (void*)this);
}

void LuaTask::stopWork() {
    mLuaEngine->stopScript();
    mThreadId = 0;
}

void* LuaTask::startWorkInner(void *args) {
    LuaTask* task = (LuaTask*) args;
    task->mLuaEngine->startScript(task->mLuaBuff, "main");
    return nullptr;
}

bool LuaTask::isRunning() {
    return mThreadId != 0;
}
複製代碼

    可是，這是咱們新建立的線程，尚未attach到JavaVM。若是沒有attach到JavaVM，就會找不到JNIEnv，因此必需要attach到JavaVM，這樣才能拿到JavaVM的JNI環境變量，從而能夠調用到Android層的方法。所以startWorkInner要改進一下：

void* startWorkInner(void *args) {
    JNIEnv* env = nullptr;
    JavaVMAttachArgs args{JNI_VERSION_1_6, nullptr, nullptr};
    g_pJvm->AttachCurrentThread(&env, &args);
    startScript()
    g_pJvm->DetachCurrentThread();
    return nullptr;
}
複製代碼

    線程退出以前，記得要和JavaVM detach一下，這樣線程才能正常退出。

5. 運行腳本包

    至此，咱們完成了可以隨時開始、中止，出錯能打印堆棧信息的執行Lua腳本功能。但實際上，咱們不可能只跑單個腳本，而且腳本可能須要一些資源文件。所以咱們通常會把腳本和資源文件打包成一個腳本包。在運行腳本以前，先解包，把腳本解析出來後再運行。 因此這個解析腳本的邏輯放在Native層仍是Android層？我我的以爲放在Android層比較好。有兩點緣由：

  1. 腳本包格式不肯定，Native層不可能爲每種狀況進行適配，既然如此那就交由使用者來解析。
  2. 單一職責的原則，Native層負責仍是隻負責一種功能比較好。並且爲解析腳本包而從新編譯一個so文件又過小題大作，因此解析的任務就交給使用者吧。

    既然提到腳本包，我就簡單談談個人實現。個人實現是把lua腳本和資源文件一塊兒壓縮成一個zip文件，在zip文件中有一個config文件，裏面寫好了全部lua腳本的相對路徑。在解析的時候，先在內存中把config解壓出來，讀出全部lua腳本的相對路徑，而後在內存中把全部lua腳本文件都解壓出來後，拼接起來，在交給Native層運行。至於資源文件，根據腳本的運行狀況進行動態解壓。我簡單的封裝了一下：

private external fun startScript(luaString: String): Boolean
external fun stopScript(): Boolean
external fun isScriptRunning(): Boolean

fun runScriptPkg(scriptPkg: File, configFile: String) {
    mThreadPool?.execute {
        val start = System.currentTimeMillis()
        initScriptPkg(scriptPkg)
        val zipFile = ZipFile(scriptPkg)
        val config = ZipFileUtils.getFileContentFromZipFile(zipFile, configFile)
        val luaScriptPaths = config.split("\r\n")
        val luaScript = ZipFileUtils.getFilesContentFromZipFile(zipFile, luaScriptPaths)
        Log.d("USE_TIME", "${System.currentTimeMillis() - start} ms")
        mHandler?.post {
            startScript(luaScript)
        }
    }
}

object ZipFileUtils {

    fun getFileContentFromZipFile(zipFile: ZipFile, targetFile: String): String {
        var ins: InputStream? = null
        try {
            val ze = zipFile.getEntry(targetFile)
            return if (ze != null) {
                ins = zipFile.getInputStream(ze)
                FileUtils.readInputStream(ins)
            } else {
                ""
            }
        } finally {
            ins?.close()
        }
    }

    fun getFilesContentFromZipFile(zipFile: ZipFile, targetFiles: List<String>): String {
        val stringBuilder = StringBuilder()
        targetFiles.filter { it.isNotEmpty() and it.isNotBlank() }.forEach {
            val content = getFileContentFromZipFile(zipFile, it)
            stringBuilder.append(content).append('\n')
        }
        return stringBuilder.toString()
    }
}

object FileUtils {

    fun readInputStream(ins: InputStream): String {
        return ins.bufferedReader().use(BufferedReader::readText)
    }
}
複製代碼

    至此，咱們在原有功能的基礎上，增長了跑腳本包的功能。完整的代碼能夠看倉庫。

6. 總結

Android層調用Lua層方法

Lua層調用Android層方法

7. 感想

    Android跑Lua腳本這個過程實際上是很簡單的，不是主要難點。此次主要卡住的地方是在JNI部分，由於我發現我所瞭解的C語言語法太古老了，跟不上如今的C語言。雖然個人C語言的代碼量也很少，加上我對JNI的一些編程規範不太瞭解，因此一路磕磕絆絆，可是總算是寫出來了。Kotlin和C/C++仍是要多熟悉熟悉，多練練。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程