【通译】(14)Stable APIs - 【通译】(7)CPU Arch ABIs

当前位置: 编程技术>移动开发

本页文章导读:

▪【通译】(14)Stable APIs 【翻译】(14)Stable APIs ----------------- 英文文档见android-ndk-r5b的documentation.html 属于Android Native Development Kit (NDK)的一部分见http://developer.android.com/sdk/ndk/（需要代理）翻译仅个人见解 -----------------.........

▪ 【通译】(7)CPU Arch ABIs 【翻译】(7)CPU Arch ABIs ----------------- 英文文档见android-ndk-r5b的documentation.html 属于Android Native Development Kit (NDK)的一部分见http://developer.android.com/sdk/ndk/（需要代理）翻译仅个人见解 ----------------.........

▪ View 格局 View 布局一、什么是View 我们上节课说，Activity是Android程序的显示层，每一个显示窗口都是一个Activity；可是Activity本身无法显示在屏幕上，我们可以把它理解成是一个抽象层，一个壳子；就.........

[1]【通译】(14)Stable APIs

来源: 互联网发布时间: 2014-02-18

【翻译】(14)Stable APIs

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

英文文档见android-ndk-r5b的documentation.html

属于Android Native Development Kit (NDK)的一部分

见http://developer.android.com/sdk/ndk/（需要代理）

翻译仅个人见解

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

Android NDK Stable APIs:

Android NDK稳定API：

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

This is the list of stable APIs/ABIs exposed by the Android NDK.

这是Android NDK暴露的稳定API/ABI列表

I. Purpose:

一、目的：

-----------

Each API corresponds to a set of headers files, and a shared library file that contains the corresponding implementation, and which must be linked against by your native code.

每个API对应一组头文件，以及包含对应实现的动态库，它必须被你的原生代码链接。

For example, to use system library "Foo", you would include a header like <foo.h> in your code, then tell the build system that your native module needs to link to /system/lib/libfoo.so at load-time by adding the following line to your Android.mk file:

例如，为了使用系统库“Foo”，你会在你的代码中包含头文件如<foo.h>，然后通过添加以下行到你的Android.mk文件以告诉构建系统你的原生模块需要在加载期链接到/system/lib/libfoo.so：

LOCAL_LDLIBS := -lfoo

Note that the build system automatically links the C library, the Math library and the C++ support library to your native code, there is no need to list them in a LOCAL_LDLIBS line.

注意构建系统自动链接C库，数学库以及C++支持库到你的原生代码，所以没必要在LOCAL_LDLIBS配置行中列出它们。

There are several "API Levels" defined. Each API level corresponds to a given Android system platform release. The following levels are currently supported:

定义了几个API级别。每个API级别对应一个给定的Android系统平台发布版。以下级别是当前支持的：

android-3 -> Official Android 1.5 system images

android-3 -> 官方Android 1.5系统镜像

android-4 -> Official Android 1.6 system images

android-4 -> 官方Android 1.6系统镜像

android-5 -> Official Android 2.0 system images

android-5 -> 官方Android 2.0系统镜像

android-6 -> Official Android 2.0.1 system images

android-6 -> 官方Android 2.0.1系统镜像

android-7 -> Official Android 2.1 system images

android-7 -> 官方Android 2.1系统镜像

android-8 -> Official Android 2.2 system images

android-8 -> 官方Android 2.2系统镜像

android-9 -> Official Android 2.3 system images

android-9 -> 官方Android 2.3系统镜像

Note that android-6 and android-7 are the same as android-5 for the NDK, i.e. they provide exactly the same native ABIs!

注意android-6和android-7对应的NDK和android-5相同，即它们提供完全相同的原生ABI！

IMPORTANT:

The headers corresponding to a given API level are now located under $NDK/platforms/android-<level>/arch-arm/usr/include

重要：

对应给定API级别的头文件现在位于$NDK/platforms/android-<level>/arch-arm/usr/include目录下

II. Android-3 Stable Native APIs:

二、Android-3稳定原生API：

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

All the APIs listed below are available for developing native code that runs on Android 1.5 system images and above.

下面列出的所有API对于开发运行在Android 1.5系统镜像和更高的原生代码可用。

The C Library:

C库：

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

The C library headers, as they are defined on Android 1.5 are available through their standard names (<stdlib.h>, <stdio.h>, etc...). If one header is not there at build time, it's because its implementation is not available on a 1.5 system image.

C库头文件，正如它们在Android 1.5所定义的那样通过它们的标准名称（<stdlib.h>、<stdio.h>等等）可用。如果一个头文件在构建期不在那里，是因为它的实现在1.5系统镜像上不可用。

The build system automatically links your native modules to the C library, you don't need to add it to LOCAL_LDLIBS.

构建系统自动地链接你的原生方法到C库，你不需要添加它到LOCAL_LDLIBS。

Note that the Android C library includes support for pthread (<pthread.h>), so "LOCAL_LIBS := -lpthread" is not needed. The same is true for real-time extensions (-lrt on typical Linux distributions).

注意Android C库包含对pthread（<pthread.h>）的支持，所以LOCAL_LIBS := -lpthread是不需要的。对于实时扩展（在典型Linux分发版中的-lrt）同样不需要。

** VERY IMPORTANT NOTE: ******************************************************

非常重要的注意事项：

The kernel-specific headers in <linux/...> and <asm/...> are not considered stable at this point. Avoid including them directly because some of them are likely to change in future releases of the platform. This is especially true for anything related to specific hardware definitions.

<linux/...>和<asm/...>的内核特定头文件此时还不认为是稳定的。避免直接包含它们，因为它们中有一些可能在未来的平台发布版中将会被修改。对于与特定硬件定义相关的任何东西尤其如此。

******************************************************************************

The Math Library:

数学库：

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

<math.h> is available, and the math library is automatically linked to your native modules at build time, so there is no need to list "-lm" through LOCAL_LDLIBS.

<math.h>可用，而且数学库在构建期自动地链接到你的原生模块，所以不需要通过LOCAL_LDLIBS列出-lm。

C++ Library:

C++库

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

An *extremely* minimal C++ support API is available. For Android 1.5, this is currently limited to the following headers:

一个极其小的C++支持API可用。对于Android 1.5，它当前被限制为以下的头文件：

<new>

<stl_pair.h>

They may not contain all definitions required by the standard. Notably, support for C++ exceptions and RTTI is not available with Android 1.5 system images.

它们可能包含标准所需的所有定义。值得注意的是，C++异常和RTTI（注：Runtime Type Information，运行时类型信息）对于Android 1.5系统镜像不可用。

The C++ support library (-lstdc++) is automatically linked to your native modules too, so there is no need to list it through LOCAL_LDLIBS

C++支持库（-lstdc++）也被自动链接到你的原生模块，所以没必要通过LOCAL_LDLIBS列出它。

Android-specific Log Support:

Android特定的日志支持：

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

<android/log.h> contains various definitions that can be used to send log messages to the kernel from your native code. Please have a look at its content in (build/platforms/android-3/common/include/android/log.h), which contain many informative comments on how to use it.

<android/log.h>包含不同的定义，可以用于从你的原生代码中发送日志消息到内核。请看看它的内容（build/platforms/android-3/common/include/android/log.h），它包含关于许多如何使用它的有用信息的注释。

You should be able to write helpful wrapper macros for your own usage to access this facility.

你应该有能力书写有用的封装宏供你自己使用以访问这个工具。

If you use it, your native module should link to /system/lib/liblog.so with:

如果你使用到它，你的原生模块应该用以下方法链接到/system/lib/liblog.so：

LOCAL_LDLIBS := -llog

ZLib Compression Library:

ZLib压缩库：

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

<zlib.h> and <zconf.h> are available and can be used to use the ZLib compression library. Documentation for it is at the ZLib page:

<zlib.h>和<zconf.h>可用，可以通过它们使用ZLib压缩库。相关文档在ZLib页面：

http://www.zlib.net/manual.html

If you use it, your native module should link to /system/lib/libz.so with:

如果你使用它，你的原生模块应该用以下方法链接到/system/lib/libz.so：

LOCAL_LDLIBS := -lz

Dynamic Linker Library:

动态链接器库

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

<dlfcn.h> is available and can be used to use the dlopen()/dlsym()/dlclose() functions provided by the Android dynamic linker. You will need to link against /system/lib/libdl.so with:

<dlfcn.h>可用，可以通过它使用由Android动态链接器提供的dlopen()/dlsym()/dlclose()函数。你将需要用以下方法链接到/system/lib/libdl.so：

LOCAL_LDLIBS := -ldl

III. Android-4 Stable Native APIs:

三、Android-4稳定原生API：

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

All the APIs listed below are available for developing native code that runs on Android 1.6 system images and above,

以下列出的所有API对于开发运行在Android 1.6系统镜像和以上的原生代码可用。

The OpenGL ES 1.x Library:

OpenGL ES 1.x库：

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

The standard OpenGL ES headers <GLES/gl.h> and <GLES/glext.h> contain the declarations needed to perform OpenGL ES 1.x rendering calls from native code.

标准OpenGL ES头文件<GLES/gl.h>和<GLES/glext.h>包含从原生代码中执行OpenGL ES 1.x渲染调用所需的声明。

If you use them, your native module should link to /system/lib/libGLESv1_CM.so as in:

如果你需要它们，你的原生模块应该像这样链接到/system/lib/libGLESv1_CM.so（注：CM是一个profile标识符，意思是Common，还有一个profile叫CL，意思是Common-Lite，详细请搜索官方文档http://www.khronos.org/registry/gles/specs/1.1/es_cm_spec_1.1.12.pdf）

LOCAL_LDLIBS := -lGLESv1_CM.so

The '1.x' here refers to both versions 1.0 and 1.1 of the OpenGL ES APIs. Please note that:

这里1.x指的是OpenGL ES API的版本1.0和1.1.请注意：

- OpenGL ES 1.0 is supported on *all* Android-based devices.

- 所有基于Android的设备支持OpenGL ES 1.0。

- OpenGL ES 1.1 is fully supported only on specific devices that have the corresponding GPU.

- 只有拥有相应GPU的特定设备才完全支持OpenGL ES 1.1。

This is because Android comes with a 1.0-capable software renderer that can be used on GPU-less devices.

这是因为Android来自拥有1.0能力的软件渲染器，可以用于缺少GPU的设备。（注：OpenGL是系统级函数库，不同于一般的应用库，它只是一组严格规定的API，既可以调用驱动程序进行硬件加速，也可以用纯软件的方法实现。OpenGL ES是OpenGL for Embedded Systems的缩写，不同于glx、wgl和agl，它是供嵌入式设备使用的经过重新设计的标准化接口，而非扩展接口）

Developers should query the OpenGL ES version string and extension string to know if the current device supports the features they need. See the description of glGetString() in the specification to see how to do that:

开发者应该查询OpenGL ES版本字符串和扩展字符串以得知当前的设备是否支持所需要的特性。参考规范中的glGetString()描述以查看如何做到这一点：

http://www.khronos.org/opengles/sdk/1.1/docs/man/glGetString.xml

Additionally, developers must put a <uses-feature> tag in their manifest file to indicate which version of OpenGL ES their application requires. See the documentation linked below for details:

另外，开发者必须在他们的清单文件中放置一个<uses-feature>标签以表明它们的程序需要哪个版本的OpenGL ES。详细请参考以下文档链接：

http://developer.android.com/guide/topics/manifest/uses-feature-element.html

Please note that, at the moment, native headers and libraries for the EGL APIs are *not* available. EGL is used to perform surface creation and flipping (instead of rendering). The corresponding operations must be performed in your VM application instead, for example with a GLSurfaceView, as described here:

请注意，现在，EGL API的原生头文件和库不可用。EGL用于执行表面创建和翻转（而非渲染）。对应的操作必须改为在你的虚拟机应用程序中执行，例如使用GLSurfaceView，像这里介绍的那样：

http://android-developers.blogspot.com/2009/04/introducing-glsurfaceview.html

The "san-angeles" sample application shows how you can do that, while rendering each frame in native code. This is a small Android port of the excellent "San Angeles Observation" demo program. For more information about it, see:

san-angeles例子应用程序展示你如何在原生代码中渲染每一帧以做到那点。这是绝妙的“San Angeles观察”演示程序的小型Android移植版。更多相关信息请参考：

http://jet.ro/visuals/san-angeles-observation/

IV. Android-5 Stable Native APIs:

四、Android-5稳定原生API：

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

All the APIs listed below are available for developing native code that runs on Android 2.0 system images and above.

下面列出的所有APi对于开发运行于Android 2.0系统镜像和以上的原生代码可用。

The OpenGL ES 2.0 Library:

OpenGL ES 2.0库：

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

The standard OpenGL ES 2.0 headers <GLES2/gl2.h> and <GLES2/gl2ext.h> contain the declarations needed to perform OpenGL ES 2.0 rendering calls from native code. This includes the ability to define and use vertex and fragment shaders using the GLSL language.

标准的OpenGL ES 2.0头文件<GLES2/gl2.h>和<GLES2/gl2ext.h>包含从原生代码中执行OpenGL ES 2.0渲染调用所需的声明。它包含通过GLSL语言定义和使用顶点和片断渲染器的能力。

If you use them, your native module should link to /system/lib/libGLESv2.so as in:

如果你使用它们，你的原生模块应该像这样链接到/system/lib/libGLESv2.so：

LOCAL_LDLIBS := -lGLESv2.so

Not all devices support OpenGL ES 2.0, developers should thus query the implementation's version and extension strings, and put a <uses-feature> tag in their Android manifest. See Section III above for details.

不是所有设备都支持OpenGL ES 2.0，因此开发者应该查询实现的版本和扩展字符串，并且把<uses-feature>标签放进它们的Android清单中。详细请参考上面的第三节。

请注意，现在，EGL API的原生头文件和库不可用。EGL用于执行表面创建和翻转（而非渲染），相应的操作必须改为在你的虚拟机应用程序中执行，例如使用GLSurfaceView，这如这里描述的那样：

http://android-developers.blogspot.com/2009/04/introducing-glsurfaceview.html

The "hello-gl2" sample application demonstrate this. It is used to draw a very simple triangle with the help of a vertex and fragment shaders.

hello-gl2例子程序展示这点。它用于在定点和片断渲染器的帮助下绘画非常简单的三角形。

IMPORTANT NOTE:

The Android emulator does not support OpenGL ES 2.0 hardware emulation at this time. Running and testing code that uses this API requires a real device with such capabilities.

重要注意事项：

目前Android模拟器不支持OpenGL ES 2.0硬件模拟。使用这个API的代码的运行和测试需要拥有这种能力的真实机器。

IV. Android-8 Stable Native APIs:

四、Android-8稳定原生API：

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

All the APIs listed below are available for developing native code that runs on Android 2.2 system images and above.

下面列出的所有API对于开发运行于Android 2.2系统镜像和以上的原生代码可用。

The 'jnigraphics' Library:

jnigraphics库

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

This is a tiny library that exposes a stable, C-based, interface that allows native code to reliably access the pixel buffers of Java bitmap objects.

这是一个小型库，暴露稳定的，基于C的接口，允许原生代码可靠地访问Java位图对象的像素缓冲器。

To use it, include the <android/bitmap.h> header in your source code, and and link to the jnigraphics library as in:

为了使用它，在你的源代码中包含<android/bitmap.h>头文件，并且像这样链接到jnigraphics库：

LOCAL_LDLIBS += -ljnigraphics

For details, read the source header at the following location:

详细请阅读以下位置的源头文件：

build/platforms/android-8/arch-arm/usr/include/android/bitmap.h

Briefly, typical usage should look like:

简单说，典型的用法看起来应该是这样：

1/ Use AndroidBitmap_getInfo() to retrieve information about a given bitmap handle from JNI (e.g. its width/height/pixel format)

1、使用AndroidBitmap_getInfo()从JNI中取出关于给定位图句柄的信息（例如它的宽、高、像素格式）

2/ Use AndroidBitmap_lockPixels() to lock the pixel buffer and retrieve a pointer to it. This ensures the pixels will not move until AndroidBitmap_unlockPixels() is called.

2、使用AndroidBitmap_lockPixels()锁定像素缓冲器，并且获得指向它的指针。这确保像素将不会被改动，直至AndroidBitmap_unlockPixels()被调用。

3/ Modify the pixel buffer, according to its pixel format, width, stride, etc.., in native code.

3、在原生代码中，根据它的像素格式、宽、步长等等，修改像素缓冲器。

4/ Call AndroidBitmap_unlockPixels() to unlock the buffer.

4、调用AndroidBitmap_unlockPixels()解除缓冲器的锁定。

V. Android-9 Stable Native APIs:

五、Android-9稳定原生API

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

All the APIs listed below are available for developing native code that runs on Android > 2.2 system images and above.

下面列出的所有API对于开发运行在Android大于2.2的系统镜像和以上的原生代码可用。

The OpenSL ES native audio Library:

OpenSL ES原生音频库：

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

Android native audio is based on Khronos Group OpenSL ES? 1.0.1.

Android原生音频库是基于Khronos Group OpenSL ES 1.0.1。

The standard OpenSL ES headers <SLES/OpenSLES.h> and <SLES/OpenSLES_Platform.h> contain the declarations needed to perform audio input and output from the native side of Android.

标准的OpenSL ES头文件<SLES/OpenSLES.h>和<SLES/OpenSLES_Platform.h>包含从Android的原生方执行音频输入和输出所需的声明。

NOTE: Despite the fact that the current OpenSL ES specification uses <OpenSLES.h> to include these headers, Khronos is currently modifying the document to recommend <SLES/OpenSLES.h> instead, hence the later approach was adopted for Android.

注意：尽管事实上当前OpenSL ES规范使用<OpenSLES.h>包含这些头文件，但是现在Khronos修改文档并建议用<SLES/OpenSLES.h>取代之，因此Android采用后者的方案。

This API level also provides Android-specific extensions, see the content of <SLES/OpenSLES_Android.h> and <SLES/OpenSLES_AndroidConfiguration.h> for details.

这个API级别还提供Android特定的扩展，详细请参见<SLES/OpenSLES_Android.h>和<SLES/OpenSLES_AndroidConfiguration.h>的内容

The system library named "libOpenSLES.so" implements the public native audio functions. Use the following to link your modules against it:

称为libOpenSLES.so的系统库实现公共原生音频函数。使用以下方法把你的模块链接它：

LOCAL_LDLIBS += -lOpenSLES

The Android native application APIs:

Android原生应用程序API：

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

Starting from API level 9, it is possible to entirely write an Android application with native code (i.e. without any Java). That does not mean that your code does not run inside a VM though, and most of the features of the platform will still need to be accessed through JNI.

从API级别9开始，可以完全用原生代码书写Android应用程序（即不需要任何Java代码）。但并不意味着你的代码不是运行在虚拟机中，平台的大多数特性仍需要通过JNI来访问。

For more information about this topic, please read the dedicated document named docs/NATIVE-ACTIVITY.html (TODO: WRITE DOC).

关于这个话题的更多信息，请阅读名为docs/NATIVE-ACTIVITY.html专用文档（待完成：写文档）

The following headers correspond to these new native APIs (see comments inside them for more details):

以下头文件对应这些新的原生API（更详细请参见它们里面的注释）

Activity lifecycle management (and general entry point)

活动生命周期管理(以及常规入口点)

To Listen to input events and sensors directly from native code.

从原生代码中直接监听输入事件和传感器。

Window management, including the ability to lock/unlock the pixel buffer to draw directly into it.

窗口管理，包含锁定和解锁像素缓冲器的能力以方便直接绘画它。

Direct (read-only) access to assets embedded in your .apk. or the Opaque Binary Blob (OBB) files, a new feature of Android X.X that allows one to distribute large amount of application data outside of the .apk (useful for game assets, for example).

直接（只读）访问嵌入到你的.apk或不透明二进制块（OBB）（注：可能是指一种文件格式）中的资源，一种Android X.X的新特性，允许开发者在.apk外部分发大数据量的应用程序数据（例如对游戏资源有用）（注：因为Android保存.apk的地方一般不能放太多数据，大文件一般存放在sd卡中）

All the corresponding functions are provided by the "libandroid.so" library version that comes with API level 9. To use it, use the following:

从API级别9开始所有对应的函数由libandroid.so库版本提供。要使用它，使用以下行：

LOCAL_LDLIBS += -landroid

[2] 【通译】(7)CPU Arch ABIs

来源: 互联网发布时间: 2014-02-18

【翻译】(7)CPU Arch ABIs

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

英文文档见android-ndk-r5b的documentation.html

属于Android Native Development Kit (NDK)的一部分

见http://developer.android.com/sdk/ndk/（需要代理）

翻译仅个人见解

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

Android Native CPU ABI Management

Android原生CPU ABI 管理

Introduction:

介绍：

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

Every piece of native code generated with the Android NDK matches a given "Application Binary Interface" (ABI) that defines exactly how your application's machine code is expected to interact with the system at runtime.

每个用Android NDK生成的原生代码匹配一个给定的“应用程序二进制接口”（ABI），ABI精确地定义了你的应用程序及其代码期待如何在运行时如何和系统交互。

A typical ABI describes things in *excruciating* details, and will typically include the following information:

一个典型的ABI用艰涩的细节描述事情，通常包含以下信息：

- the CPU instruction set that the machine code should use

- 机器代码应该使用的CPU指令集

- the endianness of memory stores and loads at runtime

- 运行时的内存存取的排列次序（注：通常分为大端和小端）

- the format of executable binaries (shared libraries, programs, etc...) and what type of content is allowed/supported in them.

- 可执行二进制文件（动态库，程序，等等）的格式以及它们里面允许和支持的是什么类型的内容。

- various conventions used to pass data between your code and the system (e.g. how registers and/or the stack are used when functions are called, alignment constraints, etc...)

- 在你的代码和系统之间传递数据时使用的不同约定（例如，在函数调用时寄存器和/或堆栈如何使用，对齐限制，等等）

- alignment and size constraints for enum types, structure fields and arrays.

- 枚举类型的对齐和大小限制，结构体字段和数组。

- the list of function symbols available to your machine code at runtime, generally from a very specific selected set of libraries.

- 在运行时对你的机器代码可用的函数符号列表，通常来源于一个非常特定的库集合。

This document lists the exact ABIs supported by the Android NDK and the official Android platform releases.

这个文档列出Android NDK和官方Android平台发布版支持的精确ABI。

I. Supported ABIs:

一、支持的ABI：

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

Each supported ABI is identified by a unique name.

每个支持的ABI通过一个唯一的名称标识。

I.1. 'armeabi'

一.1. 'armeabi'

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

This is the name of an ABI for ARM-based CPUs that support *at* *least* the ARMv5TE instruction set. Please refer to following documentation for more details:

这是针对基于ARM CPU的ABI名称，它至少支持ARMv5TE指令集。详细请参考以下文档：

- ARM Architecture Reference manual (a.k.a ARMARM)

- ARM架构参考手册（即ARMARM）

- Procedure Call Standard for the ARM Architecture (a.k.a. AAPCS)

- ARM架构的过程调用标准（即AAPCS）

- ELF for the ARM Architecture (a.k.a. ARMELF)

- ARM架构的ELF格式（即ARMELF）

- ABI for the ARM Architecture (a.k.a. BSABI)

- ARM架构的ABI（即BSABI）

- Base Platform ABI for the ARM Architecture (a.k.a. BPABI)

- ARM架构的基础平台ABI（即BPABI）

- C Library ABI for the ARM Architecture (a.k.a. CLIABI)

- ARM架构的C库ABI（即CLIABI）

- C++ ABI for the ARM Architecture (a.k.a. CPPABI)

- ARM架构的C++ ABI（即CPPABI）

- Runtime ABI for the ARM Architecture (a.k.a. RTABI)

- ARM架构的运行时ABI（即RTABI）

- ELF System V Application Binary Interface (DRAFT - 24 April 2001)

- ELF系统V应用程序二进制接口（DRAFT - 2001年4月24日)

- Generic C++ ABI (http://www.codesourcery.com/public/cxx-abi/abi.html)

- 泛型C++ ABI（http://www.codesourcery.com/public/cxx-abi/abi.html）

Note that the AAPCS standard defines 'EABI' as a moniker used to specify a _family_ of similar but distinct ABIs. Android follows the little-endian ARM GNU/Linux ABI as documented in the following document:

注意AAPCS标准定义EABI作为一个绰号，用于指定一类相似但不同的ABI。Android允许在以下文档中介绍的小端ARM GNU/Linux ABI：

http://www.codesourcery.com/gnu_toolchains/arm/arm_gnu_linux_abi.pdf

With the exception that wchar_t is only one byte. This should not matter in practice since wchar_t is simply *not* really supported by the Android platform anyway.

例外的是wchar_t只有一个字节。实际上没有关系，因为事实上wchar_t直接就不被Android平台支持。

This ABI does *not* support hardware-assisted floating point computations. Instead, all FP operations are performed through software helper functions that come from the compiler's libgcc.a static library.

这种ABI不支持硬件辅助的浮点计算。反之，所有浮点操作由编译器的libgcc.a静态库的软件辅助函数执行。

Thumb (a.k.a. Thumb-1) instructions are supported. Note that the NDK will generate thumb code by default, unless you define LOCAL_ARM_MODE in your Android.mk (see docs/ANDROID-MK.html for all details).

支持Thumb（即Thumb-1）指令。注意NDK默认将生成thumb，除非你在你的Android.mk中定义LOCAL_ARM_MODE（所有细节请参考docs/ANDROID-MK.html）

I.2. 'armeabi-v7a'

一.2. armeabi-v7a

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

This is the name of another ARM-based CPU ABI that *extends* 'armeabi' to include a few CPU instruction set extensions as described in the following document:

这是另一种基于ARM的CPU ABI，它扩展了armeabi以包含少量在下面的文档中描述的CPU指令集扩展。

- ARM Architecture v7-a Reference Manual

- ARM架构V7-a参考手册

The instruction extensions supported by this Android-specific ABI are:

被这个Android特定的ABI支持的指令扩展有：

- The Thumb-2 instruction set extension.

- Thumb-2指令集扩展。

- The VFP hardware FPU instructions.

- 向量浮点硬件的浮点处理单元指令。

More specifically, VFPv3-D16 is being used, which corresponds to 16 dedicated 64-bit floating point registers provided by the CPU.

更特别地，VFPv3-D16使用这种ABI，对应CPU提供的16个专用64位浮点寄存器。

Other extensions described by the v7-a ARM like Advanced SIMD (a.k.a. NEON), VFPv3-D32 or ThumbEE are optional to this ABI, which means that developers should check *at* *runtime* whether the extensions are available and provide alternative code paths if this is not the case.

其它扩展由v7-a ARM描述，像高级SIMD（即NEON），VFPv3-D32或ThumbEE对于这种ABI是可选的，意味着开发者应该在运行期检查扩展是否可用，并且在它们不可用的时候提供可替换的代码路径。

(Just like one typically does on x86 systems to check/use MMX/SSE2/etc... specialized instructions).

（就像有些人通常在x86系统上为了检查和使用MMX/SSE2/等等的特殊化指令而做的事情那样）。

You can check docs/CPU-FEATURES.html to see how to perform these runtime checks, and docs/CPU-ARM-NEON.html to learn about the NDK's support for building NEON-capable machine code too.

你可以检查docs/CPU-FEATURES.html以查看如何执行这些运行期检查，还可以查看docs/CPU-ARM-NEON.html以知道关于NDK对构建NEON能力机器代码的支持。

IMPORTANT NOTE: This ABI enforces that all double values are passed during function calls in 'core' register pairs, instead of dedicated FP ones. However, all internal computations can be performed with the FP registers and will be greatly sped up.

重要注意：这种ABI强制在函数调用中所有double值在“核心”寄存器对中传递。而不是专用的浮点寄存器，所有内部计算可以用浮点寄存器执行而将大大地加快速度。

This little constraint, while resulting in a slight decrease of performance, ensures binary compatibility with all existing 'armeabi' binaries.

这个小限制，当导致轻微的性能下降时，确保对所有现存armeabi二进制文件的二进制兼容性。

IMPORTANT NOTE: The 'armeabi-v7a' machine code will *not* run on ARMv5 or ARMv6 based devices.

重要注意：armeabi-v7a机器代码将不能运行于基于ARMv5和ARMv6的设备上。

I.3. 'x86'

一.3. x86

----------

This is the name of an ABI for CPUs supporting the instruction set commonly named 'x86' or 'IA-32'. More specifically, this targets the instruction set commonly referenced as 'i686' or 'Pentium Pro' in documents such as:

这是针对支持一般称为x86或IA-32的指令集的CPU的ABI名称。更特别地，它的目标是在以下文档中通常称为i686或Pentium Pro的指令集：

Intel IA-32 Intel Architecture Software Developer's Manual volume 2: Instruction Set Reference

Intel IA-32 Intel架构软件开发者手册卷2：指令集参考

IMPORTANT IMPORTANT IMPORTANT IMPORTANT IMPORTANT IMPORTANT:

重要：

THE 'x86' ABI IS AN EXPERIMENTAL FEATURE THAT IS NOT FULLY SUPPORTED YET BY THIS NDK RELEASE. TRYING TO USE IT WILL RESULT IN AN ERROR DURING THE BUILD PROCESS.

x86 ABI是一个实验性质的特性，在这个NDK发布版中尚未完全支持。尝试使用它将导致构建过程错误。

Note that optional features like MMX/SSE2/SSE3/3DNow!/KVM must be explicitly tested at runtime by the generated machine code and cannot be assumed to be everywhere.

注意可选特性像MMX/SSE2/SSE3/3DNow!/KVM必须在运行期被生成的机器代码显式地测试，不能假设它在任何地方都存在。

II. Generating code for a specific ABI:

二、生成特定ABI的代码：

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

By default, the NDK will generate machine code for the 'armeabi' ABI. You can however add the following line to your Application.mk to generate ARMv7-a compatible machine code instead:

默认，NDK将生成armeabi ABI的机器代码。然而你可以改为添加以下行到你的Application.mk以生成ARMv7-a兼容的机器代码。

APP_ABI := armeabi-v7a

It is also possible to build machine code for *two* distinct ABIs by using:

还可以通过使用以下方法构建两种不同ABI的机器代码：

APP_ABI := armeabi armeabi-v7a

This will instruct the NDK to build two versions of your machine code: one for each ABI listed on this line. Both libraries will be copied to your application project path and will be ultimately packaged into your .apk.

这将命令NDK构建你的两种版本的机器代码：对应这行中列出的每种ABI。两个库将被复制到你的应用程序工程路径并且最终被打包进你的.apk

Such a package is called a "fat binary" in Android speak since it contains machine code for more than one CPU architecture. At installation time, the package manager will only unpack the most appropriate machine code for the target device. See below for details.

这种包用Android的话来说就是“肥胖的二进制库”，因为它包含多于一种CPU架构的机器代码。在安装期，包管理器将只抽取对目标设别最合适的机器代码。详细见下。

III. ABI Management on the Android platform:

三、Android平台的ABI管理

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

This section provides specific details about how the Android platform manages native code in application packages.

这个章节提供关于Android平台管理应用程序包中原生代码的特定细节。

III.1. Native code in Application Packages:

三.1. 应用程序包内的原生代码

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

It is expected that shared libraries generated with the NDK are stored in the final application package (.apk) at locations of the form:

期望NDK所生成的动态库以这种格式的位置保存在最终的应用程序包（.apk）中：

lib/<abi>/lib<name>.so

Where <abi> is one of the ABI names listed in section II above, and <name> is a name that can be used when loading the shared library from the VM as in:

这里<abi>是上面第二节列举的ABI名称之一，而<name>是在虚拟机加载动态库时使用的名称，就像这样：

System.loadLibrary("<name>");

Since .apk files are just zip files, you can trivially list their content with a command like:

因为.apk文件只是zip文件，你可以用这样的命令简单地列出它们的内容：

unzip -l <apk>

to verify that the native shared libraries you want are indeed at the proper location. You can also place native shared libraries at other locations within the .apk, but they will be ignored by the system, or more precisely by the steps described below; you will need to extract/install them manually in your application.

以验证你想要的原生动态库确实是在合适的位置。你还可以在.apk中把原生动态库放在其它位置，但它们将被系统忽略，或者更准确地按照下面的描述的步骤做；你将需要在你的应用程序中手工地抽取或安装它们。

In the case of a "fat" binary, two distinct libraries are thus placed in the .apk, for example at:

对于“肥胖”的二进制库文件，在.apk中放置两种不同的库，例如：

lib/armeabi/libfoo.so

lib/armeabi-v7a/libfoo.so

III.2. Android Platform ABI support:

三.2. Android平台ABI支持：

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

The Android system knows at runtime which ABI(s) it supports. More precisely, up to two build-specific system properties are used to indicate:

Android系统在运行期知道它支持哪个或哪些ABI。更准确说，使用多达两个的构建特定的系统属性来指出：

- the 'primary' ABI for the device, corresponding to the machine code used in the system image itself.

- 设备的第一ABI，对应于系统镜像自身使用的机器代码。

- an optional 'secondary' ABI, corresponding to another ABI that is also supported by the system image.

- 一个可选的第二ABI，对应系统镜像支持的另一个ABI。

For example, a typical ARMv5TE-based device would only define the primary ABI as 'armeabi' and not define a secondary one.

例如，一个典型的基于ARMv5TE的设备将只把第一ABI定义为armeabi，而不会定义第二ABI。

On the other hand, a typical ARMv7-based device would define the primary ABI to 'armeabi-v7a' and the secondary one to 'armeabi' since it can run application native binaries generated for both of them.

另一方面，一个典型的基于ARMv7的设备将把第一ABI定义为armeabi-v7a，而把第二ABI定义为armeabi，因为它都可以运行由它们生成的应用程序原生二进制文件。

III.3. Automatic extraction of native code at install time:

三.3. 安装期本地代码的自动抽取

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

When installing an application, the package manager service will scan the .apk and look for any shared library of the form:

当安装一个应用程序，包管理器服务将扫描.apk并且寻找这种格式的动态库：

lib/<primary-abi>/lib<name>.so

If one is found, then it is copied under $APPDIR/lib/lib<name>.so, where $APPDIR corresponds to the application's specific data directory.

如果找到一个，那么它被复制到$APPDIR/lib/lib<name>.so，这里$APPDIR对应于应用程序的特定数据目录。

If none is found, and a secondary ABI is defined, the service will then scan for shared libraries of the form:

如果什么都没找到，而定义了一个第二ABI，那么服务将继续以这种格式寻找动态库：

lib/<secondary-abi>/lib<name>.so

If anything is found, then it is copied under $APPDIR/lib/lib<name>.so

如果找到文件，那么它被复制到$APPDIR/lib/lib<name>.so。

This mechanism ensures that the best machine code for the target device is automatically extracted from the package at installation time.

这种机制确保对于目标设备最佳的机器代码在安装期被自动从包中抽取出来。

[3] View 格局

来源: 互联网发布时间: 2014-02-18

View 布局

一、什么是View

我们上节课说，Activity是Android程序的显示层，每一个显示窗口都是一个Activity；可是Activity本身无法显示在屏幕上，我们可以把它理解成是一个抽象层，一个壳子；就譬如一个JSP页面，它本身并没有显示出来任何东西，负责显示的是他生成的HTML标签。那么 Android里谁才是真正显示出来的部分？－－是View和ViewGroup，而ViewGroup其实也是View的子类。

有了上述的概念，我们现在可以讲明白一个Activity中的显示元素是如何显示出来的了。首先UI组件是按层次结构来由外到内的方式逐步展示的。要将一个屏幕元素层次树绑定在一个屏幕上显示，Activity会调用它的setContentView()方法并且传入这个层次树的根节点引用。当 Activity被激活并且获得焦点时，系统会通知activity并且请求根节点去计算并绘制树，根节点就会请求它的子节点去绘制它们自己。每个树上的 ViewGroup节点会负责绘制它的子节点。ViewGroup会计算它的有效空间，布局所有的子显示对象，并最终调用所有的子显示对象的 Draw()方法来绘制显示对象。各个子显示对象可以向父对象请求它们在布局中的大小和位置，但最终决定各个子显示对象的大小和位置的是父对象。

Android程序借助View和ViewGroup对象来构建用户界面。Android提供了比HTML多得多的，现成的用户界面组件，譬如现在网站上常见的五角星评分效果组件RatingBar。RatingBar的显示效果如下图所示：

二、常用Layout介绍

ViewGroup是个特殊的View，它继承于Android.view.View。它的功能就是装载和管理下一层的View对象或 ViewGroup对象，也就说他是一个容纳其它元素的的容器。ViewGroup是布局管理器（layout）及view容器的基类。 ViewGroup中，还定义了一个嵌套类ViewGroup.LayoutParams。这个类定义了一个显示对象的位置、大小等属性，view通过 LayoutParams中的这些属性值来告诉父级，它们将如何放置。

ViewGroup是一个抽象类，所以真正充当容器的是他的子类们。我们在这里将介绍帧布局FrameLayout，线性布局LinearLayout，绝对布局AbsoluteLayout，相对布局RelativeLayout，表格布局TableLayout等几个常用布局，大约要分3讲讲完。

1、帧布局 FrameLayout：

是最简单的一个布局对象。在他里面的的所有显示对象爱你过都将固定在屏幕的左上角，不能指定位置，但允许有多个显示对象，只是后一个会直接覆盖在前一个之上显示，会把前面的组件部分或全部挡住。下图的例子里，FrameLayout中放了3个ImageView组件，第一个是蓝色的，第二个是绿色的，第三个是树状图（透明的png格式）。ImageView就相当于Html中的img标签，接下来会讲到这个组件。

下面看一个FrameLayout的例子：

<?xml version=”1.0″ encoding=”utf-8″?>

<ImageView android:id=”@+id/ImageView01″ android:src=/blog_article/”@drawable/p1″_br/index.html>android:layout_width=”wrap_content” android:layout_height=”wrap_content”></ImageView>

<ImageView android:id=”@+id/ImageView02″ android:src=/blog_article/”@drawable/p2″_br/index.html>android:layout_width=”wrap_content” android:layout_height=”wrap_content”></ImageView>

<ImageView android:id=”@+id/ImageView03″ android:src=/blog_article/”@drawable/p3″_br/index.html>android:layout_width=”wrap_content” android:layout_height=”wrap_content”></ImageView>

</FrameLayout>

完整的代码在PPT附带的目录中，需要的朋友可以留言向我索要。

(FrameLayout的显示效果)

2、线性布局 LinearLayout：

线性布局是所有布局中最常用的类之一，也是RadioGroup, TabWidget, TableLayout, TableRow, ZoomControls类的父类。LinearLayout可以让它的子元素垂直或水平的方式排成一行（不设置方向的时候默认按照垂直方向排列）。

下面看一个LinearLayout的例子：别被例子的长度吓住，仔细看一下其实就是一个LinearLayout中放5个TextView标签而已，TextView相当于Html标签中的Label。

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:gravity=”center_horizontal”
>
<TextView
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”给小宝宝起个名字：”
android:textSize=”20px”
android:textColor=”#0ff”
android:background=”#333″

/>
<TextView
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:text=”遥遥是男孩的小名”
android:textSize=”20px”
android:textColor=”#0f0″
android:background=”#eee”
android:layout_weight=”3″
/>
<TextView
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:text=”瑶瑶是女孩的小名”
android:textColor=”#00f”
android:textSize=”20px”
android:background=”#ccc”
android:layout_weight=”1″
/>

下图是显示效果：

3、绝对布局 AbsoluteLayout

绝对定位AbsoluteLayout，又可以叫做坐标布局，可以直接指定子元素的绝对位置，这种布局简单直接，直观性强，但是由于手机屏幕尺寸差别比较大，使用绝对定位的适应性会比较差。

下面我们举一个例子看看：例子里的机器人图片大小是250X250，可以看到我们使用android:layout_x和android:layout_y来指定子元素的纵横坐标。

<?xml version=”1.0″ encoding=”utf-8″?>
<AbsoluteLayout android:id=”@+id/AbsoluteLayout01″
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
xmlns:android=”http://schemas.android.com/apk/res/android”
android:background=”#fff”>

<ImageView
android:src=/blog_article/”@drawable/android”_br/index.html>android:layout_y=”40dip”
android:layout_width=”wrap_content”
android:layout_x=”35dip”
android:id=”@+id/ImageView01″
android:layout_height=”wrap_content”>
</ImageView>
<TextView
android:layout_height=”wrap_content”
android:layout_width=”fill_parent”
android:id=”@+id/TextView01″
android:text=”Android2.2 学习指南”
android:textColor=”#0f0″
android:textSize=”28dip”
android:layout_y=”330dip”
android:layout_x=”35dip “>
</TextView>
<TextView
android:layout_height=”wrap_content”
android:layout_width=”fill_parent”
android:id=”@+id/TextView02″
android:text=”图文并茂，理论清晰，操作性强”
android:textColor=”#333″
android:textSize=”18dip”
android:layout_y=”365dip”
android:layout_x=”35dip “>
</TextView>
</AbsoluteLayout>

让我们看一下在WQVGA的模拟器下的显示效果：

再在WVGA800的模拟器下看看显示效果：

Tip: 在绝对定位中，如果子元素不设置layout_x和layout_y，那么它们的默认值是0，也就是说它会像在FrameLayout一样这个元素会出现在左上角。

4、相对布局 RelativeLayout

相对布局 RelativeLayout 允许子元素指定它们相对于其父元素或兄弟元素的位置，这是实际布局中最常用的布局方式之一。它灵活性大很多，当然属性也多，操作难度也大，属性之间产生冲突的的可能性也大，使用相对布局时要多做些测试。

下面我们用相对布局再做一次上面的例子，首先放置一个图片，其它两个文本分别相对上一个元素定位：

<?xml version=”1.0″ encoding=”utf-8″?>

<ImageView android:id=”@+id/ImageView01″
android:src=/blog_article/”@drawable/android”_br/index.html>android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:layout_marginTop=”40dip”
>
</ImageView>
<TextView
android:layout_height=”wrap_content”
android:layout_width=”wrap_content”
android:id=”@+id/TextView01″
android:text=”Android2.2 学习指南”
android:textColor=”#0f0″
android:textSize=”28dip”
android:layout_below=”@id/ImageView01″
android:layout_centerHorizontal=”true”
android:layout_marginTop=”10dip”>
</TextView>
<TextView
android:layout_height=”wrap_content”
android:layout_width=”wrap_content”
android:id=”@+id/TextView02″
android:text=”图文并茂，理论清晰，操作性强”
android:textColor=”#333″
android:textSize=”18dip”
android:layout_below=”@id/TextView01″
android:layout_centerHorizontal=”true”
android:layout_marginTop=”5dip “>
</TextView>
</RelativeLayout>

让我们看一下在WQVGA的模拟器下的显示效果：

再看一下在更大屏幕（WVGA800）模拟器上的显示效果：

从上图可以看到界面效果基本保持了一致，而不是像绝对定位一样龟缩在左上角；同学们看到自动缩放的功能是采用了dip做单位带来的好处。关于dip，不懂的同学可以看我在开发小知识里写的专门的文章。

下面介绍一下RelativeLayout用到的一些重要的属性：

第一类:属性值为true或false
android:layout_centerHrizontal                                           水平居中
android:layout_centerVertical                                            垂直居中
android:layout_centerInparent                                           相对于父元素完全居中
android:layout_alignParentBottom                                     贴紧父元素的下边缘
android:layout_alignParentLeft                                          贴紧父元素的左边缘
android:layout_alignParentRight                                        贴紧父元素的右边缘
android:layout_alignParentTop                                          贴紧父元素的上边缘
android:layout_alignWithParentIfMissing                            如果对应的兄弟元素找不到的话就以父元素做参照物

第二类：属性值必须为id的引用名“@id/id-name”
android:layout_below                          在某元素的下方
android:layout_above                          在某元素的的上方
android:layout_toLeftOf                       在某元素的左边
android:layout_toRightOf                     在某元素的右边

android:layout_alignTop                      本元素的上边缘和某元素的的上边缘对齐
android:layout_alignLeft                      本元素的左边缘和某元素的的左边缘对齐
android:layout_alignBottom                 本元素的下边缘和某元素的的下边缘对齐
android:layout_alignRight                    本元素的右边缘和某元素的的右边缘对齐

第三类：属性值为具体的像素值，如30dip，40px
android:layout_marginBottom              离某元素底边缘的距离
android:layout_marginLeft                   离某元素左边缘的距离
android:layout_marginRight                 离某元素右边缘的距离
android:layout_marginTop                   离某元素上边缘的距离

我们再把上面的例子重新做一遍，这一次多放一些属性在里面，大家试验一下：

<?xml version=”1.0″ encoding=”utf-8″?>

<ImageView android:id=”@+id/ImageView01″
android:src=/blog_article/”@drawable/android”_br/index.html>android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:layout_marginTop=”40dip”
android:layout_centerHorizontal=”true”>
</ImageView>