toolchainandroid_如何制定android交叉编译工具链

⑴ 如何编译 android动态链编的native c/c++code

编译环境要求：下载Android的源码，并执行完一次完整的编译。以下的所有命令均是在编译后的源码根目录下执行。

1. 编译C code
同样以hello.c为例：

#include <stdio.h>
#include <stdlib.h>

int main()
{
printf("hello, world!\n");
return 0;
}

执行以下步骤生成动态链编的binary文件：
生成目标文件：prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-gcc -I bionic/libc/arch-arm/include -I bionic/libc/include -I bionic/libstdc++/include -I bionic/libc/kernel/common -I bionic/libc/kernel/arch-arm -include system/core/include/arch/linux-arm/AndroidConfig.h -c -o hello.o hello.c
生成可执行程序：prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm- eabi-gcc -nostdlib -Bdynamic -Wl,-T,build/core/armelf.x -Wl,-dynamic-linker,/system/bin/linker -Wl,--gc-sections -Wl,-z,noreloc -o hello -Lout/target/proct/generic/obj/lib -Wl,-rpath-link=out/target/proct/generic/obj/lib -lc -lstdc++ out/target/proct/generic/obj/lib/crtbegin_dynamic.o hello.o -Wl,--no-undefined ./prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/../lib/gcc/arm-eabi/4.2.1/interwork/libgcc.a out/target/proct/generic/obj/lib/crtend_android.o

用命令file查看生成的hello文件属性：
hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), stripped
可以证明此时的hello是一个动态链编的文件。

2. 编译native c++ 代码
以hello_cpp为例：

hello_cpp.h
#ifndef HELLO_CPP_H
#define HELLO_CPP_H

class Hello
{
public:
Hello();
~Hello();
void printMessage(char* msg);
};

#endif

hello_cpp.cpp
#include <stdio.h>
#include "hello_cpp.h"

Hello::Hello()
{
}

Hello::~Hello()
{
}

void Hello::printMessage(char* msg)
{
printf("C++ example printing message: %s", msg);
}

int main(void)
{
Hello hello_obj;
hello_obj.printMessage("Hello world!\n");
return 0;
}
执行以下命令完成：
编译目标文件：prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-g++ -I bionic/libc/arch-arm/include -I bionic/libc/include -I bionic/libstdc++/include -I bionic/libc/kernel/common -I bionic/libc/kernel/arch-arm -include system/core/include/arch/linux-arm/AndroidConfig.h -fno-exceptions -fno-rtti -c -o hello_cpp.o hello_cpp.cpp
编译可执行程序：prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm- eabi-g++ -nostdlib -Bdynamic -Wl,-T,build/core/armelf.x -Wl,-dynamic-linker,/system/bin/linker -Wl,--gc-sections -Wl,-z,noreloc -o hello_cpp -Lout/target/proct/generic/obj/lib -Wl,-rpath-link=out/target/proct/generic/obj/lib -lc -lstdc++ out/target/proct/generic/obj/lib/crtbegin_dynamic.o hello_cpp.o -Wl,--no-undefined ./prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/../lib/gcc/arm-eabi/4.2.1/interwork/libgcc.a out/target/proct/generic/obj/lib/crtend_android.o

同样用file查看hello_cpp的文件属性：
hello_cpp: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), stripped

但是很不幸的是，android自带的toolchain不支持C++标准库的开发，即所有的std namespace下的类均无法使用，包括基本的string。

⑵ android ndk 用什么工具

首先需要确定目标机器的指令集。
如果是 x86 的机器，用 x86-4.4.3 版本的工具链；如果是 arm 指令的，用 arm-linux-androideabi-4.4.3 版本 (x86-4.4.3 和 arm-linux-androideabi-4.4.3 位于ndk目录中)
1、gcc 的sysroot 选项
sysroot 选项设定 gcc 在编译源码的时候，寻找头文件和库文件的根目录。可以这样调用 gcc --sysroot=/tmp/gcc-arm (及其他选项)。NDK 根目录下的 platforms 目录中的各个子目录的路径都可以直接传给 gcc --sysroot=<dir>。为了简化操作，可以在linux系统的命令终端执行以下命令，设置SYSROOT环境变量，$NDK是ndk的根目录。
$ SYSROOT=$NDK/platforms/android-8/arch-arm
2、调用 NDK gcc（第1种方法）。设置 SYSROOT之后，要把它传给 gcc 的 --sysroot 选项。由于unix/linux自带的gcc并非交叉编译工具，而我们需要使用的是ndk中提供的交叉编译工具（也是gcc），所以需要想办法让编译脚本找到ndk中的gcc，而不要去寻找系统中的gcc。而 unix/linux 系统的编译脚本常常会用 CC 环境变量来引用编译器，所以通过把 CC 设置为ndk中的gcc的路径，就能帮助编译脚本找到正确的gcc（我们还能顺便加上--sysroot选项）。
将CC 按如下设置
$ export CC="$NDK/toolchains/<name>/prebuilt/<host-system>/bin/<prefix>gcc --sysroot=$SYSROOT"
$ $CC -o foo.o -c foo.c (不必执行这一行，这条命令是调用gcc编译程序）
上面第1行之后之后，再去执行./configure 就可以编译出arm程序了。不过还需要考虑共享库的链接问题，要确保该程序没有链接ndk未提供的共享库。该方法的缺陷就是，不能使用 C++ STL（STLport 或 GNU libstdc++ ），也不能使用异常机制和RTTI。
3、调用NDK编译器（第2种方法，更简单）
android ndk 提供脚本，允许自己定制一套工具链。例如：
$NDK/build/tools/make-standalone-toolchain.sh --platform=android-5 --install-dir=/tmp/my-android-toolchain [ --arch=x86 ]
将会在/tmp/my-android-toolchain 中创建 sysroot 环境和工具链。--arch 选项选择目标程序的指令架构，默认是为 arm。
如果不加 --install-dir 选项，则会创建 /tmp/ndk/<toolchain-name>.tar.bz2。
(执行 make-standalone-toolchain.sh --help 查看帮助。)
运行之后，这样使用：
$ export PATH=/tmp/my-android-toolchain/bin:$PATH
$ export CC=arm-linux-androideabi-gcc
$ export CXX=arm-linux-androideabi-g++
$ export CXXFLAGS="-lstdc++"
执行完以上设置环境变量的命令之后，就可以直接编译了（例如，执行 ./configure 然后 make 得到的就是 arm 程序了）。不用再设定 sysroot, CC 了。而且，可以使用 STL，异常，RTTI。
4、ABI 兼容性
ndk 同时支持 arm5 和 arm7，一般只用 arm5就好了。arm7是高端一点的，NDK 默认也是 arm5 。
推荐加上 -mthumb 选项给gcc，来生成 16-bit Thumb-1 指令。
如果要用 arm7，可以设定 CFLAGS='-march=armv7-a -mfloat-abi=softfp'，使用 Thumb-2 指令，且这两个选项不能分开！
5、警告 & 限制
5.1 Windows支持
Windows 上的NDK 工具链不依赖 Cygwin，因而速度比用 Cygwin 快一点，但是这些工具不能理解
Cygwin 的路径名（例如， /cygdrive/c/foo/bar）。只能理解 C: /cygdrive/c/foo/bar 这类路径
不过，NDK 提供的build工具能够很好地应对上述问题（ndk-build）
5.2 wchar_t 支持
wchar_t 类型仅从 Android 2.3 开始支持。
在 android-9 上， wchar_t 是 4字节。并且 C语言库提供支持宽字符的函数
（例外：multi-byte 编码/解码函数和 wsprintf/wsscanf ）
在android-9 以前的平台上，wchar_t 是1字节，而且宽字符函数不起作用。
建议不使用 wchar_t，提供 wchar_t 支持是为了方便移植以前的代码。
5.3 异常， RTTI 和 STL
NDK 工具链默认支持C++异常和RTTI（Run Time Type Information），可以用 -fno-exception 和 -fno-rtti 关闭（生成的机器码更小）
注意：如果要用这两个特性，需要显式链接 libsupc++。例如： arm-linux-androideabi-g++ .... -lsupc++
NDK 提供了 libstdc++，因而可以用 STL，但需要显式链接 libstdc++ ( gcc ... -lstdc++)。不过在将来可以不用手动指定这个链接参数。

⑶ 如何使用android的ndk建立native的开发环境

从网上看了一篇使用andriod的toolchain在cygwin上来建立android的开发环境，但是在vista上编译始终失败，在xp上能够成功。但是编译的时间比较长，而且对于新手来说也比较麻烦，难道就没有简单的方法吗？google已经把andriod的ndk已经放出来了，所以我就想着打它的主意了，把它配置一下，就能来开发c的程序了。旁边小伙肯定笑了，“搞啥？，有病啊，ndk就是一个开发native code的环境。”大哥，我当然知道了，虽然使用ndk来开发native code相对容易，但是它的.mk文件我看的是云里雾里，我本来想调用自己写的另外一个so库，都不知道在.mk文件里如何写，我现在也懒的去看ndk里面的mk文件，等哪天（哪天？天晓得是哪一天）有空了好好研究一下。好了，闲话少说，开练吧。首先安装cygwin,这个网上的教程多的是，就不说了，接着下载android ndk，这个在andriod的官网上就有了，然后下载一个从android模拟器里取system lib的工具busybox,然后调用命令

$adb push busybox /dev/sample/busybox

$adb shell chmod 777 /dev/sample/busybox

$adb shell ./dev/sample/busybox tar -cf /dev/sample/libs.tar /system/lib

$adb pull /dev/sample/libs.tar libs.tar

这样就将模拟器下的 /system/lib 目录的所有库（so）文件打包并下载下来了，解压libs.tar就得到了我们所需要的所有库文件。

接着将所有的文件到 $（NDK）/build/prebuilt/windows/arm-eabi-4.2.1/lib/gcc/arm-eabi/4.2.1,好了，这个时候基本的配置工作就结束了，怎么样简单多了吧。

接着编写一个简单的c文件 tutorial01.c

#include <stdio.h>

int getinformation()

{

return 0;

}

然后编写一个Makefile文件

CC = /cygdrive/f/software/android/android-ndk-1.5_r1/build/prebuilt/windows/arm-eabi-4.2.1/bin/arm-eabi-gcc

CFLAGS = -g -O2 -fPIC -DANDROID -I ./ -I ../ -I F:/software/android/android-ndk-1.5_r1/build/platforms/android-1.5/arch-arm/usr/include

SDFLAGS = -nostdlib -Wl,-T,armelf.xsc -Wl,-soname,$@ -Wl,-shared,-Bsymbolic -lc

CRT_OBJS= -lz -lm

all: libtutorial01.so

libtutorial01.so: tutorial01.o

$(CC) $(SDFLAGS) -o $@ tutorial01.o $(CRT_OBJS)

tutorial01.o: tutorial01.c

然后make，这个时候会报错 can't find "armelf.xsc", 在ndk的目录里搜索一下，搜到之后到$（NDK）/build/prebuilt/windows/arm-eabi-4.2.1/lib/gcc/arm-eabi/4.2.1，然后make，成功。这样一个简单的so文件就生成了，这个时候如果想在android的虚拟机上运行，我们还需要给它包装一下。再编写一个文件test01.c,在这里是使用dl动态加载so文件，静态加载始终有问题，搞不清楚android是如何搜索目录，而且现在只能用绝对路径，这个问题还得仔细研究研究。

#include <string.h>

#include <jni.h>

jint

java_com_example_testffmpeg_testffmpeg_getinformation( JNIEnv* env,

jobject thiz )

{

void* filehandle = dlopen("/data/data/com.example.test/lib/libtutorial.so", RTLD_LAZY );

int ll = -1;

if(filehandle)

{

int( * getinformation ) ();

getinformation = dlsym(filehandle, "getinformation");

if( getinformation )

{

ll = getinformation();

}

else

{

ll = -3;

}

dlclose(filehandle);

filehandle=0;

}

else

{

ll = -2;

}

return ll;

}

同样再来一个Makefile文件

CC = /cygdrive/f/software/android/android-ndk-1.5_r1/build/prebuilt/windows/arm-eabi-4.2.1/bin/arm-eabi-gcc

CFLAGS = -g -O2 -fPIC -DANDROID -I ./ -I ../ -I F:/software/android/android-ndk-1.5_r1/build/platforms/android-1.5/arch-arm/usr/include

SDFLAGS = -nostdlib -Wl,-T,armelf.xsc -Wl,-shared,-Bsymbolic -Wl,-soname,$@ -lc -L ../tutorial

CRT_OBJS= -lz -lm -ldl

all: libtest01.so

libtest01.so: test01.o

$(CC) $(SDFLAGS) -o $@ test01.o $(CRT_OBJS)

ok, make一下成功。好了，接下来使用andriod的sdk写一个简单的activity， testapp来测试其运行情况，以下是test01.java的代码。

package com.example.test;

import android.app.Activity;

import android.widget.TextView;

import android.os.Bundle;

public class test01 extends Activity

{

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

/* Create a TextView and set its content.

* the text is retrieved by calling a native

* function.

*/

TextView tv = new TextView(this);

// tv.setText( stringFromJNI() );

Integer ll = getinformation();

String lls = ll.toString();

tv.setText(lls);

setContentView(tv);

}

/* A native method that is implemented by the

* 'hello-jni' native library, which is packaged

* with this application.

*/

public native int getinformation();

/* this is used to load the 'hello-jni' library on application

* startup. The library has already been unpacked into

* /data/data/com.example.HelloJni/lib/libhello-jni.so at

* installation time by the package manager.

*/

static {System.loadLibrary("test");

}

}

在eclipse中运行，在模拟器上显示0，就表示成功了。
转载

⑷ 在android中如何编译连接 c 的可执行文件

1. 在./development目录下创建一目录如：myhello
2. 进入hello目录，在其下编写自己的.c文件,如: myhello.c
#include <stdio.h>
int main()
{
printf("hello world\n");
exit(0);
//return 0;
}
3. 在hello目录中，编写Android.mk, 内容如下：
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := myhelloworld
LOCAL_SRC_FILES := myhello.c
LOCAL_MODULE_TAGS := optional
include $(BUILD_EXECUTABLE)
4. 回到Android源代码顶层目录，进行编译，make myhelloworld
5. 生成的可执行文件位于:out/target/proct/lotus/system/bin/ 目录下
6. adb push 到手机 /data 目录下,然后进入adb shell,到data目录下,执行./myhelloworld 皆可

手动编译连接【arm-eabi-gcc 的目录随andorid的版本而有变化，还有就是需要链接的文件如果比较多时，需要很多-l 就很麻烦了】
7、编译成目标文件：
#$(yourAndroid)/prebuilt/linux-x86/toolchain/[arm-eabi-4.2.1]/bin/arm-eabi-gcc -I bionic/libc/arch-arm/include/ -I bionic/libc/include -I bionic/libc/kernel/common -I bionic/libc/kernel/arch-arm -g -c helloworld.c -o hello.o
8、生成可执行代码：
#$(yourAndroid)/prebuilt/linux-x86/toolchain/[arm-eabi-4.2.1]/bin/arm-eabi-gcc -nostdlib -Bdynamic -Wl,-T,build/core/armelf.x -Wl,-dynamic-linker,/system/bin/linker -Wl,--gc-sections -Wl,-z,noreloc -o helloworld -Lout/target/proct/[generic]/obj/lib -Wl,-rpath-link=out/target/proct/[generic]/obj/lib -lc hello.o -entry=main

其中[ ]中部分根据实际情况修改

**************************************************
实验：
1. 建目录(my Android)/development/test，在该目录下新建 Android.mk和fb_test.c文件

2. Android.mk文件

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := myfbtest
LOCAL_SRC_FILES := fb_test.c
LOCAL_MODULE_TAGS := optional
include $(BUILD_EXECUTABLE)

3. 以下为fb_test.c
#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <linux/kd.h>

#include <stdio.h>

#define FBBIT_PER_PIXEL 32
#define FBBIT_PIXEL_IMAGE 16
#define PIXELS_WIDTH_BYTE 4
#define BYTE_PER_PIXEL 3
#define FB_GRAPHICS_PATH "/dev/graphics/fb0"
#define DEV_TTY0_PATH "/dev/tty0"

#define DISPLAY_ERROR -1
#define DISPLAY_SUCCESS 0

#define GET_BATTERYCAPACITY_ERR -1

#define MAX_STR 255

static struct {
int fd;
void *pixels;
struct fb_fix_screeninfo fixed;
struct fb_var_screeninfo var;
int align_xres;
} fb;

int getBatteryCapacity(void)
{
FILE *in;
char tmpStr[MAX_STR + 1];
char capfile[] = "/sys/class/power_supply/battery/capacity";

if (capfile == NULL)
return GET_BATTERYCAPACITY_ERR;

in = fopen(capfile, "rt");
if (in == NULL)
return GET_BATTERYCAPACITY_ERR;

if (fgets(tmpStr, MAX_STR, in) == NULL) {
printf("Failed to read battery capacity!\n");
fclose(in);
return GET_BATTERYCAPACITY_ERR;

}

printf("Battery capacity(ascii): %s\n", tmpStr);
fclose(in);

return 0;//atoi(tmpStr);
}

static int vt_set_graphicsmode(int graphics)
{
int fd, r;
fd = open(DEV_TTY0_PATH, O_RDWR | O_SYNC);
if (fd < 0)
return DISPLAY_ERROR;
r = ioctl(fd, KDSETMODE, graphics);
close(fd);
return r;
}

int display_init(void)
{
fb.fd = open(FB_GRAPHICS_PATH, O_RDWR);
if (fb.fd < 0)
return DISPLAY_ERROR;

if (ioctl(fb.fd, FBIOGET_FSCREENINFO, &fb.fixed) < 0)
return DISPLAY_ERROR;
if (ioctl(fb.fd, FBIOGET_VSCREENINFO, &fb.var) < 0)
return DISPLAY_ERROR;
fb.align_xres = fb.fixed.line_length /
(fb.var.bits_per_pixel >> BYTE_PER_PIXEL);

fb.pixels = mmap(0, fb.fixed.line_length * fb.var.yres_virtual,
PROT_READ | PROT_WRITE, MAP_SHARED, fb.fd, 0);
if (fb.pixels == MAP_FAILED)
return DISPLAY_ERROR;

vt_set_graphicsmode(KD_GRAPHICS);

memset(fb.pixels, 0, fb.fixed.line_length * fb.var.yres_virtual);
//display_update(fb.pixels, fb.align_xres, fb.var.yres);
fb.var.activate = FB_ACTIVATE_FORCE;
ioctl(fb.fd, FBIOPUT_VSCREENINFO, &fb.var);

printf("display_init ok\n");

return DISPLAY_SUCCESS;
}

void display_on(void)
{
ioctl(fb.fd, FBIOBLANK, FB_BLANK_UNBLANK);
}

void display_off(void)
{
ioctl(fb.fd, FBIOBLANK, FB_BLANK_POWERDOWN);
}

int main()
{
display_init();
display_off();//关显示屏

getBatteryCapacity();
sleep(5);

display_on();//开显示屏

return 0;
}

⑸ 怎么单独编bootimge android

需要先找到toolchain，一般位置在你下载的源码的android/prebuilt/***/toolchain目录内。然后通过export配置toolchain的环境。配置完成后，进入boot_imx目录，位置为android/bootable/bootloader/uboot-imx中，导入配置文件后，make一下就可以得到uboot了。然后不要改变toolchain的环境配置，再进入android/kernel_imx目录，导入配置文件后，make uImage即可得到uImage。

⑹ 如何制定android交叉编译工具链

经常搞嵌入式开发的朋友对于交叉编译环境应该并不陌生，说白了，就是一组运行在x86 PC机的编译工具，可以让你在PC机上编译出目标平台（例如ARM）可识别的二进制文件。Android平台也提供了这样的交叉编译工具链，就放在Android的NDK开发包的toolchains目录下，因此，我们的Makefile文件中，只需给出相应的编译工具即可。
废话就先说到这，直接上例子，我们目标是把下面这个math.c文件编译成一个静态库文件：
#include <stdio.h>
int add( int a , int b ) {
return a+b;
}
你需要编写一个Makefile文件，这里假设你的Android ndk被安装在 /opt/android/ndk 目录下，当然，你可以根据自己的实际情况修改Makefile中相关路径的定义，Makefile文件示例如下：
# Makefile Written by ticktick
# Show how to cross-compile c/c++ code for android platform
.PHONY: clean
NDKROOT=/opt/android/ndk
PLATFORM=$(NDKROOT)/platforms/android-14/arch-arm
CROSS_COMPILE=$(NDKROOT)/toolchains/arm-linux-androideabi-4.6/prebuilt/linux-x86/bin/arm-linux-androideabi-
CC=$(CROSS_COMPILE)gcc
AR=$(CROSS_COMPILE)ar
LD=$(CROSS_COMPILE)ld
CFLAGS = -I$(PWD) -I$(PLATFORM)/usr/include -Wall -O2 -fPIC -DANDROID -DHAVE_PTHREAD -mfpu=neon -mfloat-abi=softfp
LDFLAGS =
TARGET = libmath.a
SRCS = $(wildcard *.c)
OBJS = $(SRCS:.c=.o)
all: $(OBJS)
$(AR) -rc $(TARGET) $(OBJS)
clean:
rm -f *.o *.a *.so
这里不讲Makefile文件的基本原理，只说明一下针对Android环境的Makefile文件编写的注意事项。
（1） CROSS_COMPILE
必须正确给出Android NDK编译工具链的路径，当在目录中执行make命令的时候，编译系统会根据 CROSS_COMPILE 前缀寻找对应的编译命令。
（2） -I$(PLATFORM)/usr/include
由于Android平台没有使用传统的c语言库libc，而是自己编写了一套更加高效更适合嵌入式平台的c语言库，所以系统头文件目录不能再使用默认的路径，必须直到Android平台的头文件目录
（3） -Wall -O2 -fPIC -DANDROID -DHAVE_PTHREAD -mfpu=neon -mfloat-abi=softfp
这些参数的意义网上基本上都有介绍，我就不一一解释了，并不都是必须添加的，但比较常用。
编译方法：
写好makefile文件，并且保存之后，就可以直接在当前目录下执行make命令，编译完成后，当前目录下会生成 libmath.a ，即可直接拿到Android的jni工程中和使用了。

⑺ 怎么使用Android源码编译c模块生成可执行文件

⑻ android studio 2.2.2 32位怎么配置ndk cmake环境

编译mac静态库这个比较简单，直接Xcode -GXcode，然后用xcodebuild命令即可。编译Andoird静态库编译android库我们同样可以引入一个toolchain文件，这里我是从 android-cmake 里面下载的。在使用这个toolchain文件之前，我们先要使用ndk自带的make-standalone-toolchain.sh脚本来生成对应平台的toolchain.这个脚本位于你的NDK的路径下面的buil/tools目录下。比如要生成arm平台的toolchain，我们可以使用下列命令: sh $ ANDROID_NDK / build / tools / make - standalone - toolchain . sh -- platform = android - $ANDROID_API_LEVEL -- install - dir = . / android - toolchain -- system = darwin - x86_64 -- ndk - dir = /Users / guanghui / AndroidDev / android - ndk - r9d / -- toolchain = arm - linux - androideabi - 4.8 这里的$ANDROID_NDK为你的NDK的安装路径。这段命令可以生成arm的toolchain，最终可以编译出armeabi和armeabi-v7a静态库。如果想生成x86的toolchain，指需要使用下列命令: sh $ ANDROID_NDK / build / tools / make - standalone - toolchain . sh -- platform = android - $ANDROID_API_LEVEL -- install - dir = . / android - toolchain - x86 -- system = darwin - x86_64 -- ndk - dir= / Users / guanghui / AndroidDev / android - ndk - r9d / -- toolchain = x86 - 4.8 最后，我们要告诉CMake使用外部toolchain文件，可以使用参数-DCMAKE_TOOLCHAIN_FILE=xxx。此外，我们还需要在导出两个环境变量给此toolchain文件: ...编译mac静态库这个比较简单，直接Xcode -GXcode，然后用xcodebuild命令即可。编译Andoird静态库编译android库我们同样可以引入一个toolchain文件，这里我是从 android-cmake 里面下载的。在使用这个toolchain文件之前，我们先要使用ndk自带的make-standalone-toolchain.sh脚本来生成对应平台的toolchain.这个脚本位于你的NDK的路径下面的buil/tools目录下。比如要生成arm平台的toolchain，我们可以使用下列命令: sh $ ANDROID_NDK / build / tools / make - standalone - toolchain . sh -- platform = android - $ANDROID_API_LEVEL -- install - dir = . / android - toolchain -- system = darwin - x86_64 -- ndk - dir = /Users / guanghui / AndroidDev / android - ndk - r9d / -- toolchain = arm - linux - androideabi - 4.8 这里的$ANDROID_NDK为你的NDK的安装路径。这段命令可以生成arm的toolchain，最终可以编译出armeabi和armeabi-v7a静态库。如果想生成x86的toolchain，指需要使用下列命令: sh $ ANDROID_NDK / build / tools / make - standalone - toolchain . sh -- platform = android - $ANDROID_API_LEVEL -- install - dir = . / android - toolchain - x86 -- system = darwin - x86_64 -- ndk - dir= / Users / guanghui / AndroidDev / android - ndk - r9d / -- toolchain = x86 - 4.8 最后，我们要告诉CMake使用外部toolchain文件，可以使用参数-DCMAKE_TOOLCHAIN_FILE=xxx。此外，我们还需要在导出两个环境变量给此toolchain文件: export PATH = $ PATH : . / android - toolchain / bin export ANDROID_STANDALONE_TOOLCHAIN = . / android - toolchain cmake - DCMAKE_TOOLCHAIN_FILE = . . / android . toolchain . cmake - DANDROID_ABI = "armeabi" . .收起

⑼ 不同的android有不同的toolchain么

搞清楚一点就好。toochain是干什么的？
是为了在与目标机不同的环境下编译出能在目标机上执行的代码。
比如说在x86机器的linux下编译能跑在arm上的android的内核，那么只要找到一个linux-86 -arm的toochain就可以。这个也可以用android源码自带的toolchain。理由是因为内核并不需要用到bionic。
如果编译android，那就要用android自带的toolchain，因为如斑竹所说，android用的c库是bionic而不是标准的libc，而且加载库使用的/system/bin/linker而不是常用的/lib/ld.so; 因此用其他的toolchain则只能编译成静态的才能跑。当然如果能够制作出兼容bionic的toolchain出来理论上也是能用的，不过没看到过成功的例子。
说错的地方请拍砖。

导航:首页 > 操作系统 > toolchainandroid

toolchainandroid

与toolchainandroid相关的资料