關(guān)于Android import-module 和NDK_MODULE_PATH

===========================

1、將NDK代碼模塊化

2、導(dǎo)出1個(gè)預(yù)編譯庫(kù)

===========================

1、將NDK代碼模塊化

Android module paths (sharing code made easy):

Android模塊路徑（方便同享代碼）：

==============================================

Starting from r5, the Android NDK comes with a cool feature that allows you to share and reuse other peoples modules more easily.

從r5開(kāi)始，Android NDK引入1個(gè)很酷的特性，允許你更容易地同享和重用他人的模塊。

I. Overview:

1、概述：

------------

The main idea behind this feature are:

這個(gè)特性背后的主要思想：

- You can install NDK modules outside of your main project source tree.

- 你可以在你的主工程源碼樹(shù)之外安裝NDK模塊

- You can easily import them into your project with a one-line command.

- 你可以用1個(gè)單行命令簡(jiǎn)單地“導(dǎo)入”它們到你的工程。

In practice, heres how this works:

實(shí)際上，這里介紹它是如何工作的：

1. Your NDK_MODULE_PATH environment variable will contain a list of search paths on your system to lookup for modules.

1. 你的NDK_MODULE_PATH環(huán)境變量將包括1個(gè)在你的系統(tǒng)上查找模塊的搜索路徑列表。

It is up to you to set the variable, and to copy other modules to the directories you listed in it.

由你來(lái)決定設(shè)置變量和復(fù)制你在其中列出的目錄下的其他模塊。

2. To import a module, place a line like the following to, preferably at the *end* of, your Android.mk:

2. 要想導(dǎo)入1個(gè)模塊，放置以下所示的1行指令，最好放在你的Android.mk文件結(jié)束處：

$(call import-module,)

This will look for/Android.mk under any of the directories listed in your NDK_MODULE_PATH.

這將查找在你的NDK_MODULE_PATH中列出的任意目錄下的/Android.mk

(The reason why it must be at the end is to avoid messing with the results of the my-dir function. See its description in docs/ANDROID-MK.html for details).

（它必須放在結(jié)束處的理由是為了不my-dir函數(shù)結(jié)果的干擾。詳細(xì)請(qǐng)參考docs/ANDROID-MK.html中的描寫）。

3. Declare that your projects modules depend on the imported one by listing them in either your LOCAL_STATIC_LIBRARIES or LOCAL_SHARED_LIBRARIES. For example:

3. 通過(guò)在你的LOCAL_STATIC_LIBRARIES或LOCAL_SHARED_LIBRARIES中列出它們，聲明你的工程模塊依賴于這個(gè)導(dǎo)入模塊。例如：

LOCAL_STATIC_LIBRARIES +=

4. Rebuild!

4. 重新構(gòu)建！

Remember that NDK r5 also added the ability for a module to "export" declarations to other modules that depend on it (for example, see the definition of LOCAL_EXPORT_CFLAGS in docs/ANDROID-MK.html).

記住NDK r5還添加模塊的能力以“導(dǎo)出”聲明到其它依賴于它的模塊（例如，參考docs/ANDROID-MK.html中LOCAL_EXPORT_CFLAGS的定義）

A well-written module will correctly export all the things its dependees need, et voila.

1個(gè)書(shū)寫良好的模塊將正確地導(dǎo)出它的被依賴者所需要的所有東西，就是這模樣（注：et voila是法語(yǔ)）。

Now for the full details:

現(xiàn)在是完全的細(xì)節(jié)：

I. NDK_MODULE_PATH:

1、NDK_MODULE_PATH：

-------------------

The NDK_MODULE_PATH variable must contain a list of directories.

NDK_MODULE_PATH變量必須包括1個(gè)目錄列表。

* Due to GNU Make limitations, NDK_MODULE_PATH must not contain any space. The NDK will complain if this is not the case.

* 由于GNU Make的限制，NDK_MODULE_PATH不準(zhǔn)包括任何空格。NDK將解釋它是不是背背要求。

* Use : as the path separator.

* 使用分號(hào)作為路徑分隔符。

* On Windows, use / as the directory separator.

* 在Windows上，使用正斜杠作為目錄分隔符（注：應(yīng)當(dāng)是指把Windows風(fēng)格的反斜杠改成正斜杠）。

The directories of NDK_MODULE_PATH will be searched in order. The first//Android.mk file that is found during the lookup will be included automatically.

NDK_MODULE_PATH的目錄將被順次搜索。第1個(gè)在查找種被找到的//Android.mk文件將自動(dòng)被包括。

As a convenience, $NDK/sources is appended to your NDK_MODULE_PATH definition by the NDK build system. This allows you to easily import the helper libraries that come with it (see docs/CPU-FEATURES.html for a practical example).

作為約定，$NDK/sources被NDK構(gòu)建系統(tǒng)尾加到你的NDK_MODULE_PATH定義中。這允許你簡(jiǎn)單地導(dǎo)入由它生成的輔助庫(kù)（見(jiàn)docs/CPU-FEATURES.html中的1個(gè)實(shí)際例子）

II. Writing an import module:

2、書(shū)寫1個(gè)導(dǎo)入模塊：

-----------------------------

Writing an import module is trivial and very similar to what you do when writing project modules:

書(shū)寫1個(gè)導(dǎo)入模塊是細(xì)小而且非常類似于你在書(shū)寫工程模塊時(shí)所做的東西：

1. Create a sub-directory from one of your NDK_MODULE_PATH directories.

1. 在你的NDK_MODULE_PATH目錄中的1個(gè)目錄下創(chuàng)建子目錄。

For example, if NDK_MODULE_PATH is defined to /home/user/ndk-modules, then create the directory /home/user/ndk-modules/my-module/

例如，如果NDK_MODULE_PATH被定義為/home/user/ndk-modules，那末創(chuàng)建目錄/home/user/ndk-modules/my-module/

2. Place an Android.mk and eventual source code there.

2. 在那里放置1個(gè)Android.mk和終究源碼。

Just like you would for a project module, where these files normally go to $PROJECT_PATH/Android.mk. In the example above, this would go to /home/user/ndk-modules/my-module/Android.mk

就像你對(duì)1個(gè)工程模塊那樣，這些文件通常去到$PROJECT_PATH/Android.mk中。在上面的例子中，它將集中到/home/user/ndk-modules/my-module/Android.mk

NOTE: Any Application.mk file here will be ignored.

注意：這里任何Application.mk文件將被疏忽。

3. Any module that depends on your new module, would import by calling the import-module function. For example:

3. 依賴于你的新模塊的任何模塊，將通過(guò)調(diào)用import-module函數(shù)進(jìn)行導(dǎo)入。例如：

$(call import-module,my-first-module)

Import modules *can* import other modules, but circular dependencies are not permitted and will be detected. Dependencies are transitive and the build system will compute all the things that need to be built for you.

導(dǎo)入模塊可以導(dǎo)入其他模塊，但不允許循環(huán)依賴，它會(huì)被檢測(cè)到。依賴是及物的，構(gòu)建系統(tǒng)將為你計(jì)算所有需要被構(gòu)建的所有東西。

The NDK build system will not place object files or executables in your import module directory (they will all be placed under the projects build directory, e.g. $PROJECT_PATH/obj/).

NDK構(gòu)建系統(tǒng)將不會(huì)在你的導(dǎo)入模塊目錄中放置對(duì)象文件或可履行文件（它們將全部放在工程的構(gòu)建目錄下，例如$PROJECT_PATH/obj/）

You can however distribute prebuilt binaries in your import module with the new PREBUILT_STATIC_LIBRARIES or PREBUILT_SHARED_LIBRARIES feature (see docs/ANDROID-MK.html).

但是你可以通過(guò)新的PREBUILT_STATIC_LIBRARIES或PREBUILT_SHARED_LIBRARIES特性，在你的導(dǎo)入模塊中分發(fā)預(yù)構(gòu)建2進(jìn)制文件（見(jiàn)docs/ANDROID-MK.html）。

This makes it easy to package and redistribute your import module directory to third-parties.

這將使打包和重新分發(fā)你的導(dǎo)入模塊目錄到第3方變得簡(jiǎn)單。

III. Naming an import module:

3、命名1個(gè)導(dǎo)入模塊：

-----------------------------

It is important to understand a few things related to the naming of your import module:

重要是要理解關(guān)于你的導(dǎo)入模塊命名的1些事情：

- What import-module does is really search for a file named Android.mk using the list provided by NDK_MODULE_PATH, then include while performing very little bit of house-keeping.

- import-module所做的實(shí)際上是使用NDK_MODULE_PATH提供的列表搜索名為Android.mk的文件，然后當(dāng)履行非常小量的內(nèi)部工作時(shí)包括它。

Your imported Android.mk can define any number of modules, with any name. As a consequence, there is no direct relationship betweenin the following line:

你的導(dǎo)入Android.mk可以通過(guò)名稱定義任意數(shù)量的模塊。因此，在下面指令行中之間不會(huì)有直接的關(guān)聯(lián)：

$(call import-module,/)

And the names of the modules defined under//Android.mk.

和定義在//Android.mk下的模塊名稱。

IN CASE OF DOUBT, KEEP IT SIMPLE!

如果還是不明白，就讓它保持簡(jiǎn)單！

If you only plan to provide one import module, just name it like the base import directory.

如果你只是計(jì)劃提供1個(gè)導(dǎo)入模塊，只要像導(dǎo)入基目錄那樣命名它就能夠了。

On the other hand, you may want to provide a static and a shared version of your module: use distinct names under the same top-level Android.mk. Consider the following build script:

另外一方面，你可能像提供你的模塊的靜態(tài)和動(dòng)態(tài)版本：在相同的頂級(jí)Android.mk下使用不同的名稱。斟酌以下構(gòu)建腳本：

$NDK_MODULE_PATH/foo/bar/Android.mk:

LOCAL_PATH := $(call my-dir)

# Static version of the library is named bar_static

# 庫(kù)的靜態(tài)版本被命名為bar_static

include $(CLEAR_VARS)

LOCAL_MODULE := bar_static

LOCAL_SRC_FILES := bar.c

# Ensure our dependees can include too

# 確保我們的被依賴者還可以包括

LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)

include $(BUILD_STATIC_LIBRARY)

# Shared version of the library is named bar_shared

# 庫(kù)的動(dòng)態(tài)版被命名為bar_shared

LOCAL_MODULE := bar_shared

LOCAL_SRC_FILES := bar.c

LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)

include $(BUILD_SHARED_LIBRARY)

Another module would refer to it by doing the following:

另外一個(gè)模塊將通過(guò)以下方法援用它：

1. Import foo/bar, as in:

1. 導(dǎo)入foo/bar，像這樣：

$(call import-module,foo/bar)

2. To use the static library:

2. 要使用靜態(tài)庫(kù)：

...

LOCAL_STATIC_LIBRARIES := bar_static

3. Or to use the shared library:

3. 或要使用動(dòng)態(tài)庫(kù)：

...

LOCAL_SHARED_LIBRARIES := bar_shared

- The module namespace is flat, so try to give your modules names that are likely to not collide with other. Note that your can use LOCAL_MODULE_FILENAME to give the name of your modules binary file, independently from its LOCAL_MODULE (see docs/ANDROID-MK.html for definition and usage). For example:

- 模塊的命名空間是平的，所以嘗試給你的模塊1個(gè)不可能和其它模塊名稱沖突的名字。注意你可使用LOCAL_MODULE_FILENAME設(shè)置你的模塊的2進(jìn)制文件的名稱，獨(dú)立于LOCAL_MODULE（見(jiàn)docs/ANDROID-MK.html取得其定義和用法）。例如：

include $(CLEAR_VARS)

LOCAL_MODULE := super_foo

LOCAL_MODULE_FILENAME := foo   # will give libfoo.so # 將給定為libfoo.so

LOCAL_SRC_FILES := foo-src.c

LOCAL_CFLAGS := -DVOLUME=11

include $(BUILD_SHARED_LIBRARY)

include $(CLEAR_VARS)

LOCAL_MODULE := normal_foo

LOCAL_MODULE_FILENAME := foo   # will also give libfoo.so # 還將給定為libfoo.so

LOCAL_SRC_FILES := foo-src.c

include $(BUILD_SHARED_LIBRARY)

Defines two modules named "super_foo" and "normal_foo" which both produce a shared library named libfoo.so

定義兩個(gè)模塊，名為super_foo和normal_foo，它們都將產(chǎn)生1個(gè)名為libfoo.so的動(dòng)態(tài)庫(kù)。

As a consequence, only one of them can be used by your project or a conflict will happen at build time. This allows you to select either the normal or optimized version in your NDK build scripts, while keeping the same simple loading instruction in your Java sources as:

因此，只有它們其中1個(gè)可以被你的工程使用或在構(gòu)建期產(chǎn)生沖突。這允許你用你的NDK構(gòu)建腳本選擇正常或優(yōu)化版本，保持在你的Java源代碼中這模樣的相同而且簡(jiǎn)單的加載指令：

static {

System.loadLibrary("foo");

}

IV. Tips & Recommendations:

4、提示和建議：

---------------------------

* You dont need to import a module before you can reference it!

* 你不需要在你可以援用它前導(dǎo)入模塊！

* Use import-module at the *end* of your Android.mk to avoid messing with the result of my-dir. See the description of this function in docs/ANDROID-MK.html to understand why.

* 在你的Android.mk結(jié)束處使用import-module以免my-dir結(jié)果的干擾。參考docs/ANDROID-MK.html中這個(gè)函數(shù)的描寫以理解為何。

* It is *strongly* suggested to use a subdirectory for your import tags, that describes its origin, as in:

* 強(qiáng)烈建議對(duì)你的導(dǎo)入標(biāo)簽使用子目錄，以描寫它的來(lái)源，像這模樣：

$(call import-module,gtk/glib)

or something like:

或類似這樣：

$(call import-module,com.example/awesomelib)

IMPORTANT: THE android IMPORT DIRECTORY, AND ANY OF ITS SUB-DIRECTORIES IS *RESERVED* FOR NDK USAGE. FEEL FREE TO ORGANIZE YOUR OTHER IMPORT MODULES AS YOU WANT OTHERWISE.

重要：“android”導(dǎo)入目錄，和它的任意子目錄由于NDK的使用而保存。但是歡迎你依照自己的意愿組織其它導(dǎo)入模塊。

2、導(dǎo)出1個(gè)預(yù)編譯庫(kù)

NDK Prebuilt library support:

NDK 預(yù)構(gòu)建庫(kù)支持：

-----------------------------

Android NDK r5 introduced support for prebuilt libraries (shared and static), i.e. the ability to include and use, in your applications, prebuilt version of libraries.

Android NDK r5引入預(yù)構(gòu)建庫(kù)（動(dòng)態(tài)和靜態(tài)）的支持，即在你的利用程序中包括和使用庫(kù)的預(yù)構(gòu)建版本。

This feature can be useful for two things:

這個(gè)特性可能在兩方面有用：

1/ You want to distribute your own libraries to third-party NDK developers without distributing your sources.

1、你想發(fā)布你自己的庫(kù)給第3方NDK開(kāi)發(fā)者而不分發(fā)你的源代碼。

2/ You want to use a prebuilt version of your own libraries to speed up your build.

2、你想使用你自己的庫(kù)的預(yù)構(gòu)建版本以加速你的構(gòu)建。

This document explains how this support works.

這個(gè)文檔解釋這類支持是如何工作的。

I. Declaring a prebuilt library module:

1、聲明1個(gè)預(yù)構(gòu)建庫(kù)模塊：

---------------------------------------

Each prebuilt library must be declared as a *single* independent module to the build system. Here is a trivial example where we assume that the file "libfoo.so" is located in the same directory than the Android.mk below:

每一個(gè)預(yù)構(gòu)建庫(kù)必須向構(gòu)建系統(tǒng)聲明為1個(gè)單1獨(dú)立模塊。這里有個(gè)小示例，我們假定文件libfoo.so位于以下Android.mk相同的目錄中。

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := foo-prebuilt

LOCAL_SRC_FILES := libfoo.so

include $(PREBUILT_SHARED_LIBRARY)

Notice that, to declare such a module, you really only need the following:

注意，要聲明這個(gè)模塊，你實(shí)際上只需要以下東西：

1. Give the module a name (here foo-prebuilt). This does not need to correspond to the name of the prebuilt library itself.

1. 給模塊1個(gè)名稱（這里是foo-prebuilt）。不需要對(duì)應(yīng)預(yù)構(gòu)建庫(kù)本身的名稱。

2. Assign to LOCAL_SRC_FILES the path to the prebuilt library you are providing. As usual, the path is relative to your LOCAL_PATH.

2. 把你提供的預(yù)構(gòu)建庫(kù)的路徑賦給LOCAL_SRC_FILES。通常路徑相對(duì)你的LOCAL_PATH

IMPORTANT: You *must* ensure that the prebuilt library corresponds to the target ABI you are using. More on this later.

重要：你必須確保預(yù)構(gòu)建庫(kù)對(duì)應(yīng)你正在使用的目標(biāo)ABI（注：利用程序2進(jìn)制接口，即操作系統(tǒng)開(kāi)放給利用程序的接口）。更多相干信息見(jiàn)后。

3. Include PREBUILT_SHARED_LIBRARY, instead of BUILD_SHARED_LIBRARY, if you are providing a shared, library. For static ones, use PREBUILT_STATIC_LIBRARY.

3. 包括PREBUILT_SHARED_LIBRARY，而非BUILD_SHARED_LIBRARY，如果你提供的是1個(gè)動(dòng)態(tài)庫(kù)。對(duì)靜態(tài)庫(kù)，請(qǐng)使用PREBUILT_STATIC_LIBRARY

A prebuilt module does not build anything. However, a copy of your prebuilt shared library will be copied into $PROJECT/obj/local, and another will be copied and stripped into $PROJECT/libs/.

1個(gè)預(yù)構(gòu)建模塊不編譯任何東西。但是，你的預(yù)構(gòu)建動(dòng)態(tài)庫(kù)的副本將被復(fù)制到$PROJECT/obj/local，而另外一個(gè)副本將被復(fù)制并裁剪進(jìn)$PROJECT/libs/。

II. Referencing the prebuilt library in other modules:

2、援用其它模塊的預(yù)構(gòu)建庫(kù)：

------------------------------------------------------

Simply list your prebuilt modules name in the LOCAL_STATIC_LIBRARIES or LOCAL_SHARED_LIBRARIES declaration in the Android.mk of any module that depends on them.

在依賴于你的構(gòu)建模塊的所有模塊的Android.mk的LOCAL_STATIC_LIBRARIES或LOCAL_SHARED_LIBRARIES的聲明中簡(jiǎn)單列出這些預(yù)構(gòu)建模塊的名稱。

For example, a naive example of a module using libfoo.so would be:

例如，1個(gè)使用libfoo.so的模塊的單純例子將是：

include $(CLEAR_VARS)

LOCAL_MODULE := foo-user

LOCAL_SRC_FILES := foo-user.c

LOCAL_SHARED_LIBRARY := foo-prebuilt

include $(BUILD_SHARED_LIBRARY)

III. Exporting headers for prebuilt libraries:

3、導(dǎo)出預(yù)構(gòu)建庫(kù)的頭文件：

----------------------------------------------

The example above was called naive because, in practice, the code in foo-user.c is going to depend on specific declarations that are normally found in a header file distributed with the prebuilt library (e.g. "foo.h").

上面的例子被稱為“單純”是由于，實(shí)際上，foo-user.c的代碼將依賴于特定的聲明，那些聲明通常在預(yù)構(gòu)建庫(kù)分發(fā)的頭文件中找到（例如，foo.h）

In other words, foo-user.c is going to have a line like:

換句話說(shuō)，foo-user.c將有類似的1行：

#include

And you need to provide the header and its include path to the compiler when building the foo-user module.

而你需要在構(gòu)建foo-user模塊時(shí)提供頭文件和它的編譯器包括目錄。

A simple way to deal with that is to use exports in the prebuilt module definition. For example, assuming that a file "foo.h" is located under the include directory relative to the prebuilt module, we can write:

1個(gè)簡(jiǎn)單處理方法是在預(yù)構(gòu)建模塊定義中使用導(dǎo)出。例如，假定1個(gè)foo.h文件位于相對(duì)預(yù)構(gòu)建模塊的include目錄下，我們可以這樣寫：

include $(CLEAR_VARS)

LOCAL_MODULE := foo-prebuilt

LOCAL_SRC_FILES := libfoo.so

LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include

include $(PREBUILT_SHARED_LIBRARY)

The LOCAL_EXPORT_C_INCLUDES definition here ensures that any module that depends on the prebuilt one will have its LOCAL_C_INCLUDES automatically prepended with the path to the prebuilts include directory, and will thus be able to find headers inside that.

這里L(fēng)OCAL_EXPORT_C_INCLUDES的定義確保任何依賴于預(yù)構(gòu)建模塊的模塊將自動(dòng)具有帶預(yù)構(gòu)建庫(kù)包括目錄為前置值的LOCAL_C_INCLUDES，而它將能夠找到包括其中的頭文件。

IV. Debugging prebuilt binaries:

4、調(diào)試預(yù)構(gòu)建2進(jìn)制文件：

--------------------------------

We recommend you to provide prebuilt shared libraries that contain debug symbols. The version that is installed into $PROJECT/libs// is always stripped by the NDK build system, but the debug version will be used for debugging purposes with ndk-gdb.

我們建議你提供包括調(diào)試符號(hào)的預(yù)構(gòu)建同享庫(kù)。安裝進(jìn)$PROJECT/libs//的版本常常是被NDK構(gòu)建系統(tǒng)裁剪過(guò)（注：ndk提供的工具鏈中包括了strip工具，它應(yīng)當(dāng)是用來(lái)優(yōu)化生成文件的大?。?，但調(diào)試版本將可以供ndk-gdb使用以到達(dá)調(diào)試目的。

V. ABI Selection of prebuilt binaries:

5、預(yù)構(gòu)建2進(jìn)制文件的ABI選擇：

--------------------------------------

As said previously, it is crucial to provide a prebuilt shared library that is compatible with the targetted ABI during the build. To do that, check for the value of TARGET_ARCH_ABI, its value will be:

正如前面所說(shuō)，關(guān)鍵問(wèn)題是在構(gòu)建期間提供1個(gè)兼容于目標(biāo)ABI的預(yù)構(gòu)建動(dòng)態(tài)庫(kù)（注：開(kāi)源是好事?。?。為了做到那點(diǎn)，檢查TARGET_ARCH_ABI的值，它的值將是：

armeabi     => when targetting ARMv5TE or higher CPUs

armeabi     => 目標(biāo)為ARMv5TE或更高的CPU

armeabi-v7a => when targetting ARMv7 or higher CPUs

armeabi-v7a => 目標(biāo)為ARMv7或更高的CPU

x86         => when targetting x86 CPUs

x86         => 目標(biāo)為x86 CPU。

Note that armeabi-v7a systems can run armeabi binaries just fine.

注意armeabi-v7a系統(tǒng)可以很好地運(yùn)行armeabi的2進(jìn)制文件。

Heres an example where we provide two versions of a prebuilt library and select which one to copy based on the target ABI:

這里有1個(gè)例子，我們提供兩個(gè)版本的預(yù)構(gòu)建庫(kù)并且基于目標(biāo)ABI選擇哪個(gè)版本去復(fù)制。

include $(CLEAR_VARS)

LOCAL_MODULE := foo-prebuilt

LOCAL_SRC_FILES := $(TARGET_ARCH_ABI)/libfoo.so

LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include

include $(PREBUILT_SHARED_LIBRARY)

Here. we assume that the prebuilt libraries to copy are under the following directory hierarchy:

這里。我們假定要復(fù)制的預(yù)構(gòu)建庫(kù)位于以下目錄層次：

Android.mk            --> the file above

Android.mk            --> 上面的文件

armeabi/libfoo.so     --> the armeabi prebuilt shared library

armeabi/libfoo.so     --> armeabi預(yù)構(gòu)建動(dòng)態(tài)庫(kù)

armeabi-v7a/libfoo.so --> the armeabi-v7a prebuilt shared library

armeabi-v7a/libfoo.so --> armeabi-v7a預(yù)構(gòu)建動(dòng)態(tài)庫(kù)

include/foo.h         --> the exported header file

include/foo.h         --> 導(dǎo)出的頭文件

NOTE: Remember that you dont need to provide an armeabi-v7a prebuilt library, since an armeabi one can easily run on the corresponding devices.

注意：記住你不需要提供1個(gè)armeabi-v7a預(yù)構(gòu)建庫(kù)，由于armeabi版本可以更容易地運(yùn)行在相應(yīng)的裝備上。