androidjni开发教程

⑴ androidStudio如何配置NDK/JNIAndroidStudio怎么调用so动态链接库

AndroidStudio怎么调用so动态链接库？在我们日常开发中，经常会用到一些复杂的加密的算法以保证通信的安全。通常这些算法会用C或C++实现后打包成.so动态链接库并向java层开发接口方便调用。

以AndroidStudio为例

1 . 首先去下载NDK包，下载路径如下可根据自己系统定点下载

https://developer.android.google.cn/ndk/downloads/index.html

static{
System.loadLibrary("jnitext");
}
publicnativeStringget_1111CLang_1String();

⑵ Android studio如何通过jni调用openssl生成的.so动态链接库

（1）老版本，方法如下：
task NativeLibs(type: Copy) {
from(new File(project(':MyProject').buildDir, 'native-libs')) { include '**/*.so' }
into new File(buildDir, 'native-libs')
}

tasks.withType(Compile) { compileTask -> compileTask.dependsOn NativeLibs }

clean.dependsOn 'cleanCopyNativeLibs'

tasks.withType(com.android.build.gradle.PackageApplicationTask) { pkgTask ->
pkgTask.jniDir new File(buildDir, 'native-libs')
}

（2）新版本三种方法：
（2.1）打包前先生成.Jar文件后自动解包到apk文件

task nativeLibsToJar(type: Zip, description: 'create a jar archive of the native libs') {
destinationDir file("$buildDir/native-libs")
baseName 'native-libs'
extension 'jar'
from fileTree(dir: 'libs', include: '**/*.so')
into 'lib/'
}

tasks.withType(Compile) {
compileTask -> compileTask.dependsOn(nativeLibsToJar)
}

下面一句话就是打包生成目录(build\native-libs)中的.jar文件

compile fileTree(dir: "$buildDir/native-libs", include: 'native-libs.jar')

（2.2）手动生成.Jar文件后自动解包到apk文件

这个方式需要自己手动进行.SO文件压缩，具体步骤为：将所有需要使用的.so文件压缩为.zip文件（zip中的文件目录结构为： lib/armeabi/*.so）然后把zip文件后缀改为.Jar然后放到libs生成apk就ok

默认就是自动打包所有.Jar文件：

dependencies {
compile fileTree(dir: 'libs', include: '*.jar')
}

（2.3）这也就是现在正在使用的方式（推荐） ，其实无非就是把.SO文件打包到APK的lib文件夹中，假如仔细阅读了Gradle的使用方法，自然就知道其实Gradle官方在新版已经自动实现了打包.SO文件的.很简单级就是在配置的android节点下加入下面的内容就ok：

sourceSets {
main {
jniLibs.srcDirs = ['libs']
}
}

其他地方无需修改，整个项目的配置文件如下：

apply plugin: 'android'

android {
compileSdkVersion 19
buildToolsVersion "19.0.0"

defaultConfig {
minSdkVersion 16
targetSdkVersion 19
versionCode 1
versionName "1.0"
}
buildTypes {
release {
runProguard false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
}
}
sourceSets {
main {
jniLibs.srcDirs = ['libs']
}
}
}

dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
}

⑶ 如何在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 NDK应用

本文主内容：
1、 Android NDK 安装
2、 安装Cygwin与使用NDK编译
3、 在Eclipse中集成C/C++开发环境CDT
4、 安装Sequoyah插件
5、 JNI编译环境配置

本文建立在已经完成Android开发环境搭建的基础上。其基础环境至少需要包含以下内容：
1、 JDK
2、 Eclipse
3、 Android SDK and ADT
可以参考我之前的“Android开发环境搭建”。
一、Android NDK 安装与配置
下载Android NDK。下载地址：http://developer.android.com/tools/sdk/ndk/index.html
下载后解压缩到你的工作目录，例如：D:\Java\android-ndk-r8，结果如下图：

注意：samples下面包含几个实例开发演示项目，第一次接触NDK开发，建议先从示例开始。
docs内是技术文档，英语能力强的可以研究研究。
二、安装Cygwin与使用NDK编译
由于NDK开发大都涉及到C/C++在GCC环境下编译、运行，所以在Windows环境下，需要用Cygwin模拟Linux编译环境。
下载：
Cygwin的下载地址：http://www.cygwin.com/

点击右上角的“setup.exe”即可下载。
安装：
第一步：运行setup.exe程序，直接点击Next进入下一步。
第二步：选择安装方式。第一次可以采用Direct Connection在线下载安装，如有现成的离线包，可以选择离线安装（Install from Local Directory）。
第三步：选择安装目录。比如D:\Java\Cygwin，注意此目录是指Cygwin最终的安装目录，不是下载文件蚂皮数暂存目录。
第四步：设置本地包暂存路径。暂存目录默认是放到setup.exe的同级目录下，建议放到指定的文件夹，如D:\Cygwin_install_file。安装完成后把这个文件夹打包备份，以后再配置时不用重新下载。
第五步：设置网络连接方式。这个目前河蟹没爬过来，选第一个即可。
第六步：选闷首择下载站点地址。据说国内163站点的速度不错，我也是用的这个。
第七步：等待加载安装项载入，选择安装项。点击Devel-Default，使之变成Devel-Install，展开后可以看到其下的子项被选中了（网上多数教程都说选中某12个包，找起来太坑爹了，直接全下载了吧，全选多了150M左右）。此界面其他设置都不用动。

第八步：等待下载完成。下载完成时间决定于你选择的安装包数量及网络连接速度，安装我安装的版本，约983M，下载完成后会自动握乱安装到上文设置的安装目录，安装也要时间的，总时间较长，去吃个饭没啥问题。
提醒：第四步的备份建议，尽量去做。如果有备份，第二步中选择离线安装。
验证:
运行安装目录下的“Cygwin.bat”，第一次运行时，它会自动创建用户信息，用户信息存放在“.\Cygwin\home”中。
在运行“Cygwin.bat”打开的命令行窗口输入：“cygcheck -c cygwin”命令，会打印出当前Cygwin的版本和运行状态，如果status是ok的话，则cygwin运行正常。
分别输入：“make –v”和，“gcc –v”命令如果检测成功，会有make和gcc相关版本信息打印出来。

设置NDK路径：
在windows的系统环境变量中添加NDK的路径。使用“/cygdrive/d/Java/android-ndk-r8”这种Linux风格路径，如果使用Windows下的“D:\Java\android-ndk-r8”，Cygwin在编译时会发出警告。

运行Cygwin命令行，可以直接使用此环境变量，当然也可以手动的cd到该目录：

使用NDK编译程序：
现在我们用安装好的NDK来编译一个NDK提供的sample程序hello-jni（我的目录位于：D:\Java\android-ndk-r8\samples\hello-jni）。
第一步：运行Cygwin，配置环境变量后可输入“cd $ndk/samples/hello-jni/”，未配置则输入命令“cd /cygdrive/d/java/android-ndk-r8/samples/hello-jni”，进入到“hello-jni”工程目录。

第二步：编译。输入命令“$ndk/ndk-build”命令即可编译。ndk-build是调用ndk的编译程序。
关于下面的错误，我没遇到，但是前人有总结，记录如下：
错误：Android NDK: Host 'awk' tool is outdated。
解决方法：打开目录“D:\Java\android-ndk-r8\prebuilt\windows\bin\”，删除awk.exe（为保险起见请先备份）。

第三步：到”…/hello-jni/libs/armeabi“目录下看有没有生成的.so文件，如果有，你的ndk就运行正常啦！

导入NDK的hello-jni示例到Eclipse中：
第一步：在Eclipse中新建一个Android工程HelloJni。在Create Android Project时勾选“Create project from existing source”，Location中填“D:\Java\android-ndk-r8\samples\hello-jni” （注意：在选择API level时需要选择1.5或更高的版本）。
第二步：直接以Android Aplication运行。这里要注意，你之前在使用NDK编译程序时要把这个hello-jni编译过并产生了.so文件，此处才能运行起来。

三、在Eclipse中集成C/C++开发环境CDT
CDT的安装可以使我们在一个工程中，同时开发基于C/C++的Native代码和基于Java语言的壳，之后的配置还可以使得一次编译两部分代码。
下载：
下载地址：http://www.eclipse.org/cdt/downloads.php
说明：
Eclipse C/C++ IDE Indigo SR2：是带CDT的Eclipse开发环境。
p2 software repository：在线安装的地址。（似乎被河蟹爬了）
cdt-master-8.0.2.zip：这个是CDT的离线安装包。（推荐使用这个，保留离线包，复用）

离线安装：
Eclipse -> Help -> Install New Software，点击add。Name：随意，建议使用好记的“CDT_版本”。Location：点击Archive，定位到下载的“cdt-master-8.0.2.zip”文件。
错误：
如果Location的下面出现“Duplicate location”错误，请到Window -> preferences -> Install/Update -> Avaliable Software Site中找到该条，remove之。
验证：
安装完成后，在Eclispe中新建一个项目，如果出现了C/C++项目，则表明CDT插件安装成功了。

四、安装Sequoyah插件
Sequoyah插件用于设置Android工程对Native开发的支持。
官方网址：http://www.eclipse.org/sequoyah/downloads/
在线安装：
官网提供了用于在线安装的Update Site地址以及安装包的下载地址。貌似安装包才1M多，在线安装也没被河蟹爬过，直接在线安装了。勾选全部列出的可安装项并完成安装。
Location：http://download.eclipse.org/sequoyah/updates/2.0/

注意：
在安装界面不要勾选“Group items by category”复选框，默认是勾选的，出现了列表为空（There are no categorized items）的情况。

配置：
安装完Sequoyah插件后，为Android配置NDK路径。
在“window –> preferences ->Android -> 本机开发”中添加NDK的路径。

验证：
右键之前建立的“HelloJni”项目，在“Android Tools”选项中包含“Add Native Support…”选项即成功。
五、JNI编译环境配置
仍旧以之前建立的“HelloJni”为例，到目前为止，如果我们修改“/HelloJni/jni/hello-jni.c”文件，动态链接库libhello-jni.so文件却不会被重新编译生成。这是因为我们没有给JNI项目添加它需要的编译配置和依赖库。现在我们来配置它。
第一步：转换工程。点击“文件 -> 新建 -> 其他”（快捷键：Ctrl+N）。选择“C/C++”下的“Convert to a C/C++ Project（Adds C/C++ Nature）”。进入“下一步”。

第二步：选中你刚才建的“HelloJni”工程，下面左边选“Makefile project”右边选“Cygwin GCC”。确定后提示的“透视图”不清楚是什么，点击“是”即可。

第三步：在“HelloJni”工程上右键，选择“属性”。配置“C/C++ Build”和“C/C++ General -> Paths and Symbols”。
C/C++ Build：点击“C/C++ Build”，在右边的“Builder Settings”中去掉默认勾选的“Use default build command”复选框。设置Build command为“bash D:\Java\android-ndk-r8\ndk-build”。

C/C++ General -> Paths and Symbols：在Includes下add新的GNU C依赖路径。此“HelloJni”工程需要“D:\Java\android-ndk-r8\platforms\android-8\arch-arm\usr\include”即可，以后根据不同项目选择不同的依赖库。

验证：
将“/HelloJni/jni/hello-jni.c”中的字符串“Hello from JNI !”如改为“Hello JNI from Baron!”，运行后在模拟器上输出的字符串改变即说明配置成功。

⑸ 如何用Android NDK编译FFmpeg

Android内置的编解码器实在太少，于是我们需要FFmpeg。Android提供了NDK，为我们使用FFmpeg这种C语言代码提供了方便。
不过为了用NDK编译FFmpeg，还真的花费了不少时间，也得到了很多人的帮助，最应该谢谢havlenapetr。我觉得我现在这些方法算是比较简洁的了－－
下面就尽量详细的说一下我是怎么在项目中使用FFmpeg的，但是基于我混乱的表达能力，有不明白的就问我。
你得了解JNI和Android NDK的基本用法，若觉得我的文章还不错，可以看之前写的JNI简单入门和Android NDK入门
首先创建一个标准的Android项目vPlayer
android create project -n vPlayer -t 8 -p vPlayer -k me.abitno.vplayer -a PlayerView

然后在vPlayer目录里
mkdir jni && cd jni
wget http //ffmpeg org/releases/ffmpeg-0.6.tar.bz2
tar xf ffmpeg-0.6.tar.bz2 && mv ffmpeg-0.6 ffmpeg && cd ffmpeg

在ffmpeg下新建一个config.sh，内容如下，注意把PREBUILT和PLATFORM设置正确。另外里面有些参数你也可以自行调整，我主要是为了配置一个播放器而这样设置的。
#!/bin/bash

PREBUILT=/home/abitno/Android/android-ndk-r4/build/prebuilt/linux-x86/arm-eabi-4.4.0
PLATFORM=/home/abitno/Android/android-ndk-r4/build/platforms/android-8/arch-arm

./configure --target-os=linux \
--arch=arm \
--enable-version3 \
--enable-gpl \
--enable-nonfree \
--disable-stripping \
--disable-ffmpeg \
--disable-ffplay \
--disable-ffserver \
--disable-ffprobe \
--disable-encoders \
--disable-muxers \
--disable-devices \
--disable-protocols \
--enable-protocol=file \
--enable-avfilter \
--disable-network \
--disable-mpegaudio-hp \
--disable-avdevice \
--enable-cross-compile \
--cc=$PREBUILT/bin/arm-eabi-gcc \
--cross-prefix=$PREBUILT/bin/arm-eabi- \
--nm=$PREBUILT/bin/arm-eabi-nm \
--extra-cflags="-fPIC -DANDROID" \
--disable-asm \
--enable-neon \
--enable-armv5te \
--extra-ldflags="-Wl,-T,$PREBUILT/arm-eabi/lib/ldscripts/armelf.x -Wl,-rpath-link=$PLATFORM/usr/lib -L$PLATFORM/usr/lib -nostdlib $PREBUILT/lib/gcc/arm-eabi/4.4.0/crtbegin.o $PREBUILT/lib/gcc/arm-eabi/4.4.0/crtend.o -lc -lm -ldl"

运行config.sh开始configure
chmod +x config.sh
./config.sh

configure完成后，编辑刚刚生成的config.h，找到这句
#define restrict restrict

Android的GCC不支持restrict关键字，于是修改成下面这样
#define restrict

编辑libavutil/libm.h，把其中的static方法都删除。
分别修改libavcodec、libavfilter、libavformat、libavutil、libpostproc和libswscale下的Makefile，把下面两句删除
include $(SUBDIR)../subdir.mak
include $(SUBDIR)../config.mak

在ffmpeg下添加一个文件av.mk，内容如下
# LOCAL_PATH is one of libavutil, libavcodec, libavformat, or libswscale

#include $(LOCAL_PATH)/../config-$(TARGET_ARCH).mak
include $(LOCAL_PATH)/../config.mak

OBJS :=
OBJS-yes :=
MMX-OBJS-yes :=
include $(LOCAL_PATH)/Makefile

# collect objects
OBJS-$(HAVE_MMX) += $(MMX-OBJS-yes)
OBJS += $(OBJS-yes)

FFNAME := lib$(NAME)
FFLIBS := $(foreach,NAME,$(FFLIBS),lib$(NAME))
FFCFLAGS = -DHAVE_AV_CONFIG_H -Wno-sign-compare -Wno-switch -Wno-pointer-sign
FFCFLAGS += -DTARGET_CONFIG=\"config-$(TARGET_ARCH).h\"

ALL_S_FILES := $(wildcard $(LOCAL_PATH)/$(TARGET_ARCH)/*.S)
ALL_S_FILES := $(addprefix $(TARGET_ARCH)/, $(notdir $(ALL_S_FILES)))

ifneq ($(ALL_S_FILES),)
ALL_S_OBJS := $(patsubst %.S,%.o,$(ALL_S_FILES))
C_OBJS := $(filter-out $(ALL_S_OBJS),$(OBJS))
S_OBJS := $(filter $(ALL_S_OBJS),$(OBJS))
else
C_OBJS := $(OBJS)
S_OBJS :=
endif

C_FILES := $(patsubst %.o,%.c,$(C_OBJS))
S_FILES := $(patsubst %.o,%.S,$(S_OBJS))

FFFILES := $(sort $(S_FILES)) $(sort $(C_FILES))

接下来要添加一系列的Android.mk，在jni根目录下的内容如下
include $(all-subdir-makefiles)

在ffmpeg目录下，Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_STATIC_LIBRARIES := libavformat libavcodec libavutil libpostproc libswscale
LOCAL_MODULE := ffmpeg
include $(BUILD_SHARED_LIBRARY)
include $(call all-makefiles-under,$(LOCAL_PATH))

libavformat/Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
include $(LOCAL_PATH)/../av.mk
LOCAL_SRC_FILES := $(FFFILES)
LOCAL_C_INCLUDES := \
$(LOCAL_PATH) \
$(LOCAL_PATH)/..
LOCAL_CFLAGS += $(FFCFLAGS)
LOCAL_CFLAGS += -include "string.h" -Dipv6mr_interface=ipv6mr_ifindex
LOCAL_LDLIBS := -lz
LOCAL_STATIC_LIBRARIES := $(FFLIBS)
LOCAL_MODULE := $(FFNAME)
include $(BUILD_STATIC_LIBRARY)

libavcodec/Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
include $(LOCAL_PATH)/../av.mk
LOCAL_SRC_FILES := $(FFFILES)
LOCAL_C_INCLUDES := \
$(LOCAL_PATH) \
$(LOCAL_PATH)/..
LOCAL_CFLAGS += $(FFCFLAGS)
LOCAL_LDLIBS := -lz
LOCAL_STATIC_LIBRARIES := $(FFLIBS)
LOCAL_MODULE := $(FFNAME)
include $(BUILD_STATIC_LIBRARY)

libavfilter、libavutil、libpostproc和libswscale下的Android.mk内容如下
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
include $(LOCAL_PATH)/../av.mk
LOCAL_SRC_FILES := $(FFFILES)
LOCAL_C_INCLUDES := \
$(LOCAL_PATH) \
$(LOCAL_PATH)/..
LOCAL_CFLAGS += $(FFCFLAGS)
LOCAL_STATIC_LIBRARIES := $(FFLIBS)
LOCAL_MODULE := $(FFNAME)
include $(BUILD_STATIC_LIBRARY)

最外层的jni/Android.mk和jni/ffmpeg/Android.mk我只是随便这样写的，你应该根据自己的需求改写。
最后运行ndk-build，经过漫长的等待就编译完成了。至于具体怎么应用可能以后会写，我变得太懒了。。。
转载，仅供参考，祝你愉快，满意请采纳。

⑹ Android NDK开发简介 NDK和SDK以及JNI有什么关系

NDK:Android NDK 是在SDK前面又加上了“原生”二字，即Native Development Kit，因此又被Google称为“NDK”。
NDK全称：Native Development Kit。
NDK是一系列工具的集合。
* NDK提供了一系列的工具，帮助开发者快速开发C（或C++）的动态库，并能自动将so和java应用一起打包成apk。这些工具对开发者的帮助是巨大的。
* NDK集成了交叉编译器，并提供了相应的mk文件隔离CPU、平台、ABI等差异，开发人员只需要简单修改mk文件（指出“哪些文件需要编译”、“编译特性要求”等），就可以创建出so。
* NDK可以自动地将so和Java应用一起打包，极大地减轻了开发人员的打包工作。
其实：
NDK就是能够方便快捷开发.so文件的工具。JNI的过程比较复杂，生成.so需要大量操作，而NDK就是简化了这个过程。

Android SDK:
SDK （software development kit）软件开发工具包。被软件开发工程师用于为特定的软件包、软件框架、硬件平台、操作系统等建立应用软件的开发工具的集合。因此！Android SDk 指的既是Android专属的软件开发工具包

JNI:
Java Native Interface (JNI)标准是java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI 是本地编程接口，它使得在 Java 虚拟机 (VM) 内部运行的 Java 代码能够与用其它编程语言(如 C、C++ 和汇编语言)编写的应用程序和库进行交互操作
当然一般需要进行如下操作流程：
1) 编写java程序：这里以HelloWorld为例。为了实现在 java代码中调用c函数printf。
代码1：
class HelloWorld {
public native void testHelloWorld();
static {
System.loadLibrary("hello");
}
public static void main(String[] args) {
new HelloWorld().testHelloWorld();
}
}
声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。
Load动态库：System.loadLibrary("hello");
这里一般是以static块进行加载的。同时需要注意的是System.loadLibrary()的参数“hello”是动态库的名字。
2) 编译
javac HelloWorld.java
3) 生成扩展名为h的头文件 javah ?
JNIEXPORT void JNICALL Java_HelloWorld_testHelloWorld (JNIEnv *, jobject);

这个h文件相当于我们在java里面的接口，这里声明了一个 Java_HelloWorld_testHelloWorld (JNIEnv *, jobject)方法，然后在我们 的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。
4) 编写本地方法实现和由javah命令生成的头文件里面声明的方法名相同的方法

代码2：
#include "jni.h"
#include "HelloWorld.h"
#include other headers

JNIEXPORT void JNICALL Java_HelloWorld_testHelloWorld(JNIEnv *env, jobject obj)
{
printf("Hello world!/n");
return;
}
注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、 jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入。然后保存为 HelloWorldImpl.c就ok了。
5) 生成动态库
这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。 cl -I%java_home%/include -I%java_home%/include/win32 -LD HelloWorldImp.c -Fehello.dll 注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。
另外需要将-I%java_home%/include -I%java_home%/include/win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。