ubuntu编译ndk

① 如何在Android下使用JNI

1.引言
我们知道，Android系统的底层库由c/c++编写，上层Android应用程序通过java虚拟机调用底层接口，衔接底层c/c++库与Java应用程序间的接口正是JNI（JavaNative Interface)。本文描述了如何在ubuntu下配置AndroidJNI的开发环境，以及如何编写一个简单的c函数库和JNI接口，并通过编写Java程序调用这些接口，最终运行在模拟器上的过程。

2.环境配置

2.1.安装jdk1.6
（1）从jdk官方网站下载jdk-6u29-linux-i586.bin文件。
（2）执行jdk安装文件
[html] view plainprint?
01.$chmod a+x jdk-6u29-linux-i586.bin
02.$jdk-6u29-linux-i586.bin
$chmod a+x jdk-6u29-linux-i586.bin
$jdk-6u29-linux-i586.bin
(3)配置jdk环境变量

[html] view plainprint?
01.$sudo vim /etc/profile
02.#JAVAEVIRENMENT
03.exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29
04.exportJRE_HOME=$JAVA_HOME/jre
05.exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
06.exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
$sudo vim /etc/profile
#JAVAEVIRENMENT
exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29
exportJRE_HOME=$JAVA_HOME/jre
exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
保存后退出编辑，并重启系统。

（4）验证安装

[html] view plainprint?
01.$java -version
02.javaversion "1.6.0_29"
03.Java(TM)SE Runtime Environment (build 1.6.0_29-b11)
04.JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)
05.$javah
06.用法：javah[选项]<类>
07.其中[选项]包括：
08.-help输出此帮助消息并退出
09.-classpath<路径>用于装入类的路径
10.-bootclasspath<路径>用于装入引导类的路径
11.-d<目录>输出目录
12.-o<文件>输出文件（只能使用-d或-o中的一个）
13.-jni生成JNI样式的头文件（默认）
14.-version输出版本信息
15.-verbose启用详细输出
16.-force始终写入输出文件
17.使用全限定名称指定<类>（例
18.如，java.lang.Object）。
$java -version
javaversion "1.6.0_29"
Java(TM)SE Runtime Environment (build 1.6.0_29-b11)
JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)
$javah
用法：javah[选项]<类>
其中[选项]包括：
-help输出此帮助消息并退出
-classpath<路径>用于装入类的路径
-bootclasspath<路径>用于装入引导类的路径
-d<目录>输出目录
-o<文件>输出文件（只能使用-d或-o中的一个）
-jni生成JNI样式的头文件（默认）
-version输出版本信息
-verbose启用详细输出
-force始终写入输出文件
使用全限定名称指定<类>（例
如，java.lang.Object）。2.2.安装android应用程序开发环境
ubuntu下安装android应用程序开发环境与windows类似，依次安装好以下软件即可：
（1）Eclipse
（2）ADT
（3）AndroidSDK
与windows下安装唯一不同的一点是，下载这些软件的时候要下载Linux版本的安装包。
安装好以上android应用程序的开发环境后，还可以选择是否需要配置emulator和adb工具的环境变量，以方便在进行JNI开发的时候使用。配置步骤如下：
把emulator所在目录android-sdk-linux/tools以及adb所在目录android-sdk-linux/platform-tools添加到环境变量中，android-sdk-linux指androidsdk安装包android-sdk_rxx-linux的解压目录。
[plain] view plainprint?
01.$sudo vim /etc/profile
02.exportPATH=~/software/android/android-sdk-linux/tools:$PATH
03. exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH
$sudo vim /etc/profile
exportPATH=~/software/android/android-sdk-linux/tools:$PATH
exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH
编辑完毕后退出，并重启生效。

2.3.安装NDK
NDK是由android提供的编译android本地代码的一个工具。
（1）从androidndk官网http://developer.android.com/sdk/ndk/index.html下载ndk，目前最新版本为android-ndk-r6b-linux-x86.tar.bz2.
（2）解压ndk到工作目录：
[plain] view plainprint?
01.$tar -xvf android-ndk-r6b-linux-x86.tar.bz2
02.$sudo mv android-ndk-r6b /usr/local/ndk
$tar -xvf android-ndk-r6b-linux-x86.tar.bz2
$sudo mv android-ndk-r6b /usr/local/ndk
（3）设置ndk环境变量

[plain] view plainprint?
01.$sudo vim /etc/profile
02.exportPATH=/usr/local/ndk:$PATH
$sudo vim /etc/profile
exportPATH=/usr/local/ndk:$PATH

编辑完毕后保存退出，并重启生效

（4）验证安装

[plain] view plainprint?
01.$ cd/usr/local/ndk/samples/hello-jni/
02.$ ndk-build
03.Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver
04.Gdbsetup : libs/armeabi/gdb.setup
05.Install : libhello-jni.so => libs/armeabi/libhello-jni.so
$ cd/usr/local/ndk/samples/hello-jni/
$ ndk-build
Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver
Gdbsetup : libs/armeabi/gdb.setup
Install : libhello-jni.so => libs/armeabi/libhello-jni.so

3.JNI实现
我们需要定义一个符合JNI接口规范的c/c++接口，这个接口不用太复杂，例如输出一个字符串。接下来，则需要把c/c++接口的代码文件编译成共享库（动态库）.so文件，并放到模拟器的相关目录下。最后，启动Java应用程序，就可以看到最终效果了。

3.1.编写Java应用程序代码
（1）启动Eclipse，新建android工程

Project：JNITest

Package：org.tonny.jni

Activity：JNITest

（2）编辑资源文件

编辑res/values/strings.xml文件如下：编辑res/layout/main.xml文件
我们在主界面上添加了一个EditText控件和一个Button控件。

（3）编辑JNITest.java文件


static表示在系统第一次加载类的时候，先执行这一段代码，在这里表示加载动态库libJNITest.so文件。

再看这一段：

[java] view plainprint?
01.privatenativeString GetReply();
privatenativeString GetReply();
native表示这个方法由本地代码定义，需要通过jni接口调用本地c/c++代码。

[java] view plainprint?
01.publicvoidonClick(View arg0) {
02.edtName.setText(reply);
03.}
publicvoidonClick(View arg0) {
edtName.setText(reply);
}

这段代码表示点击按钮后，把native方法的返回的字符串显示到EditText控件。

（4）编译工程，生成.class文件。

3.2.用javah工具生成符合JNI规范的c语言头文件

在终端中，进入android工程所在的bin目录

[plain] view plainprint?
01.$cd ~/project/Android/JNITest/bin
$cd ~/project/Android/JNITest/bin
我们用ls命令查看，可以看到bin目录下有个classes目录，其目录结构为classes/org/tonny/jni，即classes的子目录结构是android工程的包名org.tonny.jni。请注意，下面我们准备执行javah命令的时候，必须进入到org/tonny/jni的上级目录，即classes目录，否则javah会提示找不到相关的java类。

下面继续：

[plain] view plainprint?
01.$cd classes
02.$javah org.tonny.jni.JNITest
03.$ls
04.org org_tonny_jni_JNITest.h
$cd classes
$javah org.tonny.jni.JNITest
$ls
org org_tonny_jni_JNITest.h

执行javahorg.tonny.jni.JNITest命令，在classes目录下会生成org_tonny_jni_JNITest.h头文件。如果不进入到classes目录下的话，也可以这样：

[plain] view plainprint?
01.$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest
$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest
-classpath 参数表示装载类的目录。

3.3.编写c/c++代码
生成org_tonny_jni_JNITest.h头文件后，我们就可以编写相应的函数代码了。下面在android工程目录下新建jni目录，即~/project/Android/JNITest/jni，把org_tonny_jni_JNITest.h头文件拷贝到jni目录下，并在jni目录下新建org_tonny_jni_JNITest.c文件，编辑代码如下：

[cpp] view plainprint?
01.#include<jni.h>
02.#include<string.h>
03.#include"org_tonny_jni_JNITest.h"
04.
05.
06.JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply
07.(JNIEnv *env, jobject obj){
08.return(*env)->NewStringUTF(env,(char*)"Hello,JNITest");
09.}
#include<jni.h>
#include<string.h>
#include"org_tonny_jni_JNITest.h"

JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply
(JNIEnv *env, jobject obj){
return(*env)->NewStringUTF(env,(char*)"Hello,JNITest");
}

我们可以看到，该函数的实现相当简单，返回一个字符串为："Hello,JNITest"

3.4.编写Android.mk文件
在~/project/Android/JNITest/jni目录下新建Android.mk文件，android可以根据这个文件的编译参数编译模块。编辑Android.mk文件如下：

[plain] view plainprint?
01.LOCAL_PATH:= $(call my-dir)
02.include$(CLEAR_VARS)
03.LOCAL_MODULE := libJNITest
04.LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c
05.include$(BUILD_SHARED_LIBRARY)
LOCAL_PATH:= $(call my-dir)
include$(CLEAR_VARS)
LOCAL_MODULE := libJNITest
LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c
include$(BUILD_SHARED_LIBRARY)

LOCAL_MODULE表示编译的动态库名称

LOCAL_SRC_FILES 表示源代码文件

3.5.用ndk工具编译并生成.so文件
进入到JNITest的工程目录，执行ndk-build命令即可生成libJNITest.so文件。

[plain] view plainprint?
01.$cd ~/project/Android/JNITest/
02.$ndk-build
03.Invalidattribute name:
04.package
05.Install : libJNITest.so => libs/armeabi/libJNITest.so
$cd ~/project/Android/JNITest/
$ndk-build
Invalidattribute name:
package
Install : libJNITest.so => libs/armeabi/libJNITest.so
可以看到，在工程目录的libs/armeabi目录下生成了libJNITest.so文件。

3.6.在模拟器上运行
（1）首先，我们把android模拟器启动起来。进入到emulator所在目录，执行emulator命令：

[plain] view plainprint?
01.$cd ~/software/android/android-sdk-linux/tools
02.$./emulator @AVD-2.3.3-V10 -partition-size 512
$cd ~/software/android/android-sdk-linux/tools
$./emulator @AVD-2.3.3-V10 -partition-size 512
AVD-2.3.3-V10表示你的模拟器名称，与在Eclipse->AVDManager下的AVDName对应，-partition-size表示模拟器的存储设备容量。

（2）接下来，我们需要把libJNITest.so文件拷贝到模拟器的/system/lib目录下，执行以下命令：

[plain] view plainprint?
01.$cd ~/project/Android/JNITest/libs/armeabi/
02.$adb remount
03.$adb push libJNITest.so /system/lib
04.80 KB/s (10084 bytes in 0.121s)
$cd ~/project/Android/JNITest/libs/armeabi/
$adb remount
$adb push libJNITest.so /system/lib
80 KB/s (10084 bytes in 0.121s)

当在终端上看到有80 KB/s (10084 bytes in 0.121s)传输速度等信息的时候，说明拷贝成功。

（3）在终端上执行JNITest程序，这个我们可以在Eclipse下，右键点击JNITest工程，RunAs->Android Application，即可在模拟器上启动程序

② Android Studio cmake编译FFmpeg以及Jni调用

NDK是一系列工具集，帮助开发者快速开发C（或C++）动态库，并能自动打包为APK，减轻开发人员的打包工作。它集成交叉编译器，提供mk文件隔离差异，只需修改mk文件，就能创建出.so文件，自动打包与Java应用。JNI是Java与C/C++沟通机制，用于调用本地代码，实现高效性。Android Studio 2.2后引入cMake新开发方式，简化NDK开发与调试。以下步骤完成Android下FFmpeg编译与JNI调用。

首先，在Ubuntu中创建并配置FFmpegOnAndroid目录，进行NDK安装与配置。

1. 下载并解压Android NDK，配置环境变量。

2. 编译FFmpeg源代码，修改configure文件以适应Android平台。

3. 编写build.sh脚本编译FFmpeg，执行脚本完成编译。

编译完成后，将FFmpeg库文件移植至Android平台。

1. 使用最新Android Studio2.3.3，安装cmake和ndk，新建包含C++支持的工程。

2. 在工程中创建native-lib.cpp文件，实现Java与C++间调用。

3. 配置CMakeLists.txt文件，指定库文件路径。

4. 修改jni部分代码，集成FFmpeg功能。

5. 实现Java调用代码，展示FFmpeg使用效果。

通过此过程，可以在Android设备上使用FFmpeg进行音视频处理。详细源码可参考开源仓库：[GitHub源码下载地址](DaveBobo/JniFFmpeg)

相关参考文章包括：

1. [CSDN博客文章](blog.csdn.net/eastmoon5...)

2. [CSDN博客文章](blog.csdn.net/dagaozi/a...)

3. [CSDN博客文章](blog.csdn.net/hejjunlin...)

4. [CSDN博客文章](cnblogs.com/wanggang123...)

③ 怎么样将自己开发的Android应用程序编译到系统Image中

1. 搭建编译环境
编译环境： Ubuntu 10.10
Android版本：Android 2.2

编译过程中可能需要在Ubuntu上安装必要的一些软件，我安装过的包含如下软件，不同的系统可能会有差别：
jdk6(Android官方建议装jdk5，但是我在编译时会遇到Java override问题，改用6没有任何问题), bison, lib64z1-dev, libasound2-dev, flex, gperf, libncurses5-dev

2. 应用程序存放目录
SimpleJNI是采用Android NDK和Java编写的程序，包含apk和so库文件，它的源代码在source tree的development/samples/目录下。
实际上package在编译时所放的目录并没有明确限定，编译后apk和so存放的位置是根据目录下Android.mk所指定的编译类型所决定的，例如：
SimpleJNI根目录下的Android.mk中有一行include $(BUILD_PACKAGE)，表示将该目录下的模块编译成package，即apk文件，默认存放的位置为/system/app。
SimpleJNI/jni目录下的Android.mk中有一行为include $(BUILD_SHARED_LIBRARY)，表示将该目录下的native.cpp编译为共享库文件，即so文件，默认存放的位置为/system/lib

因此，如果我们想要将自己编写的程序编译至image中，只需要将Eclipse下完成的整个工程到source tree下的某个目录即可，我一般习惯放到packages/apps下。

3. 添加Android.mk
完成了上一步，可以知道，Android.mk在编译中起着至关重要的作用，这其实就是Android编译环境中的make file。为了完成我们的工作，需要在源代码中添加Android.mk。添加自己的Android.mk可以仿照SimpleJNI中的Android.mk，稍微修改即可。我们首先看看SimpleJNI目录下的两个Android.mk的内容：
根目录下的Android.mk

TOP_LOCAL_PATH:= $(call my-dir)

# Build activity

LOCAL_PATH:= $(TOP_LOCAL_PATH)
include $(CLEAR_VARS)

LOCAL_MODULE_TAGS := samples

LOCAL_SRC_FILES := $(call all-subdir-java-files)

LOCAL_PACKAGE_NAME := SimpleJNI

LOCAL_JNI_SHARED_LIBRARIES := libsimplejni

LOCAL_PROGUARD_ENABLED := disabled

include $(BUILD_PACKAGE)

# ============================================================

# Also build all of the sub-targets under this one: the shared library.
include $(call all-makefiles-under,$(LOCAL_PATH))

根目录下的Android.mk决定了整个工程编译的配置，其中，

LOCAL_PATH 定义了当前的目录

LOCAL_MUDULE_TAGS 定义了当前模块的类型，编译器在编译时会根据类型的不同有些差别，有些tags的mole甚至不会被编译至系统中。LOCAL_MUDULE_TAGS主要有如下几种：user debug eng tests optional samples shell_ash shell_mksh。optional表示在所有版本的编译条件下都被编译至image中，剩下的表示在该版本中才会被编译只image中，如user表示在user版本下才会被编译至image中。
对于包含LOCAL_PACKAGE_NAME的mk文件，该项默认为optinal，具体可以参看build/core/package.mk。SimpleJNI中定义为samples的具体作用我也不太清楚，为了保险起见，我自己的apk一般定义为optional。

LOCAL_SRC_FILES 定义了编译apk所需要的java代码的目录

LOCAL_PACKAGE_NAME 这里需要改成自己的package的名字

LOCAL_JNI_SHARED_LIBRARIES 定义了要包含的so库文件的名字，如果你的程序没有采用JNI，这行不需要。

LOCAL_PROGUARD_ENABLED 定义了Java开发中的ProGuard压缩方法，主要用来分析压缩程序的，在我自己的应用中我没有加这行。

include $(BUILD_PACKAGE) 这行是build的关键，表示当前java代码build成apk

include $(call all-makefiles-under,$(LOCAL_PATH)) 表示需要build该目录下的子目录的文件，这样编译系统就会在当前目录下的子目录寻找Android.mk来编译so等其它程序。

根据上述所写，创建我自己的Android.mk如下：

TOP_LOCAL_PATH:= $(call my-dir)

# Build activity

LOCAL_PATH:= $(TOP_LOCAL_PATH)
include $(CLEAR_VARS)

LOCAL_MODULE_TAGS := optional

LOCAL_SRC_FILES := $(call all-subdir-java-files)

LOCAL_PACKAGE_NAME := TestJniApp

LOCAL_JNI_SHARED_LIBRARIES := libtestjniapp

include $(BUILD_PACKAGE)

# ============================================================

# Also build all of the sub-targets under this one: the shared library.
include $(call all-makefiles-under,$(LOCAL_PATH))
看起来很简单吧，基本不需要改动即可。

Jni目录下的Android.mk

由于我们的TestJniApp是用JNI完成的，包含C源代码，因此也需要一个jni目录下的Android.mk。同样首先看看SimpleJNI中jni目录下的Android.mk的内容：

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_MODULE_TAGS := samples

# This is the target being built.
LOCAL_MODULE:= libsimplejni

# All of the source files that we will compile.
LOCAL_SRC_FILES:= /
native.cpp

# All of the shared libraries we link against.
LOCAL_SHARED_LIBRARIES := /
libutils

# No static libraries.
LOCAL_STATIC_LIBRARIES :=

# Also need the JNI headers.
LOCAL_C_INCLUDES += /
$(JNI_H_INCLUDE)

# No special compiler flags.
LOCAL_CFLAGS +=

# Don't prelink this library. For more efficient code, you may want
# to add this library to the prelink map and set this to true. However,
# it's difficult to do this for applications that are not supplied as
# part of a system image.

LOCAL_PRELINK_MODULE := false

include $(BUILD_SHARED_LIBRARY)
LOCAL_MODULE 当前模块的名字，即编译后的so文件的名字

LOCAL_SRC_FILES 所要编译的文件

LOCAL_SHARED_LIBRARIES, LOCAL_STATIC_LIBRARIES 该模块要链接的动态库和静态库。

LOCAL_C_INCLUDES 要包含的头文件

LOCAL_CFLAGS C语言编译选项

LOCAL_PRELINK_MODULE 定义是否使用prelink工具，它用事先链接代替运行时链接的方法来加速共享库的加载，不仅可以加快起动速度，还可以减少部分内存开销。

经过修改后，我自己的TestJniApp中jni目录下的Android.mk如下：

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := libtestjniapp
LOCAL_SRC_FILES := com_test_app_Jni.c
LOCAL_C_INCLUDES += $(JNI_H_INCLUDE)

LOCAL_PRELINK_MODULE := false

include $(BUILD_SHARED_LIBRARY)

这里有一点需要注意，如果要将so文件编译入image，必须要修改LOCAL_MODULE_TAGS，将原有的值samples修改为user，或者可以直接删掉 。删掉是因为对于包含LOCAL_MODULE的mk文件，如果没有指定LOCAL_MODULE_TAGS，该项默认为user，而只有定义为user的情况下，才会将so文件编译入image，具体定义可以参看build/core/base_rule.mk。

4. 修改/bulid/target/proct/generic.mk 把工程编译到系统中
至此，还有最后一部工作。为了将工程编译进入image，还需要在/bulid/target/proct/generic.mk文件中将package name添加进去

PRODUCT_PACKAGES := /
AccountAndSyncSettings /
CarHome /
DeskClock /
……
SyncProvider /
TestJniApp

完成上面这些步骤后，在source tree根目录下编译image就可以了。

④ 如何在 android 设备上使用 pjsip G.729 编解码的功能

第一步是生成 pjsip 为 Android （步骤为 Ubuntu Linux） 的源代码：

1.设置 ANDROID_NDK_ROOT 环境变量设置为您 NDK 根文件夹。
2.转到 pjsip 2.x 文件夹并创建 pjlib/include/pj/config_site.h 包括 config_site_sample.h ( #include <pj/config_site_sample.h> )
3.运行./configure-android
4.运行make clean && make depend && make
之后这些步骤，将有几个静态库中的几个文件夹。建议将它们分组相同的文件夹 （最好在您的项目中） 中的：

mkdir <your_project_path>/pjsip_libs
find . -name *.a | xargs -I % cp % <your_project_path>/pjsip_libs/
一旦自己的所有库，您需要将这些库添加到您的项目 Android.mk 文件，这是由包括一个新的模块节每个图书馆。此模块部分应该是一样的东西：

include $(CLEAR_VARS)
LOCAL_MODULE := pjsua-arm-unknown-linux-androideabi
LOCAL_SRC_FILES := $(MY_PJLIB_PATH)/libpjsua-arm-unknown-linux-androideabi.a
include $(PREBUILT_STATIC_LIBRARY)
，其实是一节中构建您的 JNI 项目的源代码，所有模块都添加到您的静态库的引用：

LOCAL_STATIC_LIBRARIES := pjsua-arm-unknown-linux-androideabi ...
这将包括 pjsip 的引用加入您的 JNI 库。现在，您需要配置 pjsip UA 实例。

有一个关于 init 和开始的解释 pjsip 的 UA (pjsua) 在 pjsip/include/pjsua-lib/pjsua.h 但要遵循的主要步骤是：

1.创建一个具有 UA 实例pjsua_create
2.创建一个工作线程与pj_thread_create
3.UA 实例的设置的默认配置：

pjsua_config cfg 桩 ；pjsua_logging_config log_cfg ；pjsua_media_config media_cfg ；

pj_cli_cfg_default(&app_config.cli_cfg.cfg) ；pjsua_logging_config_default(&log_cfg) ；pjsua_media_config_default(&media_cfg) ；

4.初始化堆栈与pjsua_init

5.启动与堆栈pjsua_start
从这里，有充足的配置选项 （日志、 媒体、 交通工具等）

您可以找到基本 PJSIP 教程在这里，和里面 pjsip 的源的根路径，有一个基本 （但不够完整，基本的 SIP 使用情况） 在：pjsip-apps/src/samples/simple_pjsua.c

编辑：在生成时在 pjsip 应用程序的 android 项目，可以面临一个问题，因为 pjsua app 不生成默认情况下，对一般生成 （更具体地说，pjsua： 目标不包括所有上： 在 pjsip-应用程序/生成/生成文件的目标)。若要修复这只是转到 pjsip-应用程序/创建和运行：

使 pjsua

这将创建在正确的对象文件: pjsip-apps/build/output/pjsua-arm-unknown-linux-androideabi/ (需要构建 android 样本时)。

一旦所有相应的对象文件，您可以在 pjsip-应用程序/src/pjsua/android 系统再次运行 ndk 生成