androidjni開發as

❶ 做jni開發android系統源碼怎麼分析

Android中JNI是編譯so庫的源代碼，編譯成功後會生成SO庫，android中最終是使用SO庫的。
1.android的NDK開發需要在linux下進行： 因為需要把C/C++編寫的代碼生成能在arm上運行的.so文件，這就需要用到交叉編譯環境，而交叉編譯需要在linux系統下才能完成。
2.安裝android-ndk開發包，這個開發包可以在google android 官網下載： 通過這個開發包的工具才能將android jni 的C/C++的代碼編譯成庫
3.android應用程序開發環境： 包括eclipse、java、 android sdk、 adt等。

❷ 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文件。

❸ 如何更新android studio中的ndk

1、NDK開發就是JNI開發

這里有一點需要注意，moleName是最後編譯生成庫的名稱，當然，最終的.so文件會加一個前綴「lib」，例如上面的代碼，編譯後生成的.so文件的全名會是libpatch.so。另外，回頭看一下PatchUtil類中的static代碼塊，調用了載入庫文件的系統方法，其中的庫文件的名稱，與moleName是一致的，不要加任何前後綴。

七、所有的工作都結束了，patch方法已經可以被調用了，在Activity里起一個線程，調用PatchUtil.patch(),就可以進行APK包的合成了。

八、bsdiff下載地址中，除了可以下載bsdiff的源碼，還可以下載windows環境下的.exe可執行文件，下載下來，就可以在本地手動生成差分包，而不需要依賴伺服器了

❹ 如何入手學習android 底層開發

android 底層開發學習：
一、基於Android的CPU+GPU的異構編程開發，目前主要有以下幾種平台：
1. OpenCL
在桌面系統和大規模並行計算領域被普遍使用的一種底層API。最近一段時間，主流的晶元廠商的旗艦或准旗艦晶元都開始支持OpenCL1.1或者1.2標准，包括高通，三星， 聯發科，Rockchip等廠商的晶元，都可以找到OpenCL的支持。
2. CUDA
目前只有NVIDIA自己出的基於Tegra K1晶元的設備（NVIDIA Shield）支持CUDA，所以支持的面比較窄。
3. RenderScript （RS）
Google力推的異構編程，宗旨是由平台幫你選擇運行的處理器，也就是說你是不知道你的程序跑在CPU還是GPU上的，這是由系統的驅動來決定的。想法是美好的，可現實是開發者並不買RS的帳， 大家覺得RS的性能不可控，靈活性太差，其文檔之缺乏也被人詬病；此外，晶元廠商對於RS的優化都還普遍處於比較低階的水平，這些都導致了RS在實際應用中很少被用到。

二、由於OpenCL的普及程度，以下部分只針對OpenCL展開。
目前支持OpenCL的設備和晶元
1. 支持OpenCL的GPU
高通幾乎全系的GPU， 包括但不限於以下GPU (Adreno 305, 320, 330, 405, 420, 430, 530 ...)
ARM Mali的6系和7系GPU， 比如T628， T760

2014年以來較新的Imagination PowerVR GPU，比如G6430
2. 支持OpenCL的晶元。以下是一個很粗略地列舉了主要的支持OpenCL的晶元。

高通8064， 8974（驍龍800，801）， 8084（驍龍805）， 8994（驍龍810）等
三星 Exynos獵戶座 5420, 5433 （內置ARM Mali GPU）
聯發科 MT6752 （內置ARM Mali T760 GPU)
瑞芯微 RK3288 （內置ARM Mali GPU）
3. 支持OpenCL的手機和平板。 這個就數不勝數了，下面只隨手給出幾個例子以供參考。（注意：Google Nexus系列的手機或平板，雖然硬體上支持OpenCL，但因為刪掉了OpenCL的驅動程序，所以基本都不支持OpenCL；值得注意的是，據國外blog上報道，可以將相應的OpenCL驅動推送回設備以重新開啟OpenCL的支持， 詳見maxlv.net 的頁面）

三星 Galaxy S4， S5， S6， Note 3， Note 4
LG G2， G3， G4
HTC One M7， M8， M9
小米使用高通晶元的手機和平板
魅族M1 Note
台積電P90HD
等等等等。。。。
如果不確定手頭的設備是否支持OpenCL， 可以使用OpenCL-Z Android進行檢測，這款軟體可以顯示詳細的OpenCL的設備信息，同時運行micro-benchmark檢測設備的計算能力。
三、需要掌握的知識：
1. 簡單的GPU基本知識
2. OpenCL並行程序設計
3. Android NDK知識
4. Android JNI介面的編寫
5. 簡單的Android程序開發知識

四、開發的步驟（這里只是步驟的精簡版本，只闡述操作，不進行解釋）：
1. 編寫OpenCL的C/C++程序實現GPU的核心計算代碼
2. 用Android NDK編譯之前寫的C/C++代碼。這一階段可以在純C/C++環境下工作，可以編寫main函數測試實現的功能，用NDK將代碼編譯為可執行的代碼（BUILD_EXECUTABLE)， 然後用ADB將可執行程序推送到設備上運行。運行可執行程序要求設備具有root許可權，如果沒有root許可權，可以通過Native Program Launcher (AndroidNativeLauncher · GitHub，可能需要翻牆) 這一工具在設備上執行二進制代碼。
3. 上一階段測試結束，功能基本正常。開始編寫JNI介面。
4. 開始編寫Android應用程序，使用JNI封裝native函數。編譯C/C++代碼成動態鏈接庫。
5. 在Android程序里，以靜態方式載入上一步編譯的動態鏈接庫。
6. 在需要的地方（比如點擊按鈕事件），調用相應的native函數，即可實現相應的功能。

❺ android studio JNI開發時 編譯成功 但是沒有生成.so文件 什麼原因

1 在交叉編譯的時候怎麼都無法生成so文件，javah生成頭文件沒錯，c文件也沒錯，java文件也沒錯，
2.原因：是JNI文件夾路徑不對
3 在執行javah命令時，我進入的是cd app/src/main/java 這樣jni文件夾在java文件夾下，作為一個包存在，這樣就無法生成so文件
執行javah的正確姿勢：
4 進入app/src/main目錄：cd app/src/main
執行javah命令：javah

javah -d jni -classpath ./Java lab.sodino.jnitest.MainActivity

5， -d jni 頭文件生成到jni文件夾（當前在<Project>\app\src\main目錄下，所以.h所在的目錄為<Project>\app\src\main\jni ）
-classpath ./java 指定去當前路徑下java下尋找包名指定的類
這樣再rebuild一下，就會生成so文件了

❻ 安卓開發什麼時候使用jni

android JNI是連接android Java部分和C/C++部分的紐帶，完整使用JNI需要Java代碼和C/C++代碼。其中C/C++代碼用於生成庫文件，Java代碼用於引用C /C++庫文件以及調用C/C++方法。

android Java部分代碼：

jnitest.java
02
03packagecom.hello.jnitest;
04
05
06
07importandroid.app.Activity;
08
09importandroid.os.Bundle;
10
11
12
{
14
15/**.*/
16
17@Override
18
19publicvoidonCreate(BundlesavedInstanceState){
20
21super.onCreate(savedInstanceState);
22
23setContentView(R.layout.main);
24
25Naddtest=newNadd();
26
27setTitle("TheNativeAddResultis"+String.valueOf(test.nadd(10,20)));
28
29}
30
31}
32
33Nadd.java
34
35packagecom.hello.jnitest;
36
37
38
39publicclassNadd{
40
41static{
42
43System.loadLibrary("hello_jni");
44
45}
46
47
48
49publicnativeintnadd(inta,intb);
50
51}

Java代碼說明：

1）jnitest.java是一個activity的類對象，在該類對象中生成調用JNI函數的類對象，同時調用JNI方法，最後將JNI方法的結果顯示到標題欄上；

2）Nadd.java是一個引用和聲明JNI庫和函數的類，其中System.loadLibrary();函數用來引用JNI庫，默認JNI庫放在 android系統的/system/lib/目錄下；public nadd int nadd(int a, int b);為聲明需要在java程序中使用的JNI庫中的函數；

JNI中java部分的代碼到此就結束了，總結一下在java代碼中需要做兩件事：

1）使用System.loadLibrary()函數來引用JNI庫；

2）聲明調用JNI庫的函數且前面添加native關鍵字；

android C/C++部分代碼：

01#defineLOG_TAG"hello-JNI"
02#include<stdio.h>
03#include<stdlib.h>
04#include<unistd.h>
05#include<sys/types.h>
06#include<sys/stat.h>
07#include<fcntl.h>
08#include<assert.h>
09#include"jni.h"
10#include"JNIHelp.h"
11#include"android_runtime/AndroidRuntime.h"
12staticjintcom_hello_jnitest_jnitest_nadd(JNIEnv*env,jobjectobj,jinta,jintb)
13{
14return(a*b);
15}
[]={
17{"nadd","(II)I",(void*)com_hello_jnitest_jnitest_nadd},
18};
19staticintregister_android_test_hello(JNIEnv*env)
20{
21returnandroid::AndroidRuntime::registerNativeMethods(env,"com/hello/jnitest/Nadd",gMethods,NELEM(gMethods));
22}
23jintJNI_OnLoad(JavaVM*vm,void*reserved)
24{
25JNIEnv*env=NULL;
26if(vm->GetEnv((void**)&env,JNI_VERSION_1_4)!=JNI_OK){
27printf("ErrorGetEnv
");
28return-1;
29}
30assert(env!=NULL);
31if(register_android_test_hello(env)<0){
32printf("register_android_test_helloerror.
");
33return-1;
34}
35returnJNI_VERSION_1_4;
36}

JNI C/C++代碼說明：

1）JNI_OnLoad()函數。該函數在Java程序調用System.loadLibrary()時，被調用執行，用於向JavaVM注冊JNI函數等。在本例中首先通過參數JavaVM（Java虛擬機指針）獲取當前應用程序所在的線程，即：JNIEnv。再通過調用 android::AndroidRuntime::registerNativeMethods()注冊native實現的函數指針。

2）JNI函數和Java調用函數的映射關系。使用JNINativeMethod將java調用的函數名與JNI實現的函數名聯系在一起；

3）JNI函數實現；

Android.mk代碼：

1LOCAL_PATH:=$(callmy-dir)
2include$(CLEAR_VARS)
3LOCAL_PRELINK_MODULE:=false
4LOCAL_SRC_FILES:=
5com_hello_jnitest.cpp
6LOCAL_SHARED_LIBRARIES:=
7libandroid_runtime
8LOCAL_MODULE:=libhello_jni
9include$(BUILD_SHARED_LIBRARY)

需要注意的是：

1）JNI C/C++部分的代碼需要在android源代碼樹上進行編譯，編譯完成後我的做法是直接將生成的.so通過adb push方法上傳到android虛擬機的/system/lib/目錄下；

2）java代碼可以在eclipse下直接編譯且在虛擬機上執行；

編譯JNI C/C++部分代碼（在android內核源代碼根目錄下）：

#make libhello_jni

之後在out/target/proct/generic/system/lib/目錄下生成libhello_jni.so

上傳libhello_jni.so到android虛擬機：

#adb push out/target/proct/generic/system/lib/libhello_jni.so /system/lib

注意：此時有可能出現Out of Memory的錯誤提示。當出現如上錯誤提示時，需要使用#adb remount重新載入一下就可以了。

另外，也有可能直接使用eclipse啟動android虛擬機時出現上述錯誤且使用#adb remount也出現的情況，此時需要手動啟動android虛擬機，如：#emulator -avd xxx -partition-size 128，之後在使用#adb push就可以了。

❼ 如何在Android下使用JNI

我們知道，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官網下載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文件如下：

[html] view plainprint?
01.<?xmlversionxmlversion="1.0"encoding="utf-8"?>
02.<resources>
03.<stringnamestringname="hello">HelloWorld, JNITestActivity!</string>
04.<stringnamestringname="app_name">JNITest</string>
05.<stringnamestringname="btn_show">Show</string>
06.</resources>
<?xmlversion="1.0"encoding="utf-8"?>
<resources>
<stringname="hello">HelloWorld, JNITestActivity!</string>
<stringname="app_name">JNITest</string>
<stringname="btn_show">Show</string>
</resources>

編輯res/layout/main.xml文件如下：

[html] view plainprint?
01.<?xmlversionxmlversion="1.0"encoding="utf-8"?>
02.<LinearLayoutxmlns:androidLinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
03.android:layout_width="fill_parent"
04.android:layout_height="fill_parent"
05.android:orientation="vertical">
06.<TextView
07.android:layout_width="fill_parent"
08.android:layout_height="wrap_content"
09.android:text="@string/hello"/>
10.<EditText
11.android:id="@+id/ed_name"
12.android:layout_width="match_parent"
13.android:layout_height="wrap_content"
14.android:layout_gravity="center_horizontal"
15.android:layout_marginLeft="5dp"
16.android:layout_marginRight="5dp"/>
17.<Button
18.android:id="@+id/btn_show"
19.android:layout_width="109dp"
20.android:layout_height="wrap_content"
21.android:layout_gravity="center_horizontal"
22.android:text="@string/btn_show"/>
23.</LinearLayout>
<?xmlversion="1.0"encoding="utf-8"?>
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"/>
<EditText
android:id="@+id/ed_name"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginLeft="5dp"
android:layout_marginRight="5dp"/>
<Button
android:id="@+id/btn_show"
android:layout_width="109dp"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:text="@string/btn_show"/>
</LinearLayout>

我們在主界面上添加了一個EditText控制項和一個Button控制項。

（3）編輯JNITest.java文件

[java] view plainprint?
01.packageorg.tonny.jni;
02.
03.importandroid.app.Activity;
04.importandroid.os.Bundle;
05.importandroid.view.View;
06.importandroid.widget.EditText;
07.importandroid.widget.Button;
08.
09.
10. {
11.static{
12.System.loadLibrary("JNITest");
13.}
14.privatenativeString GetReply();
15.privateEditTextedtName;
16.privateButtonbtnShow;
17.Stringreply;
18./**Called when the activity is first created. */
19.@Override
20.publicvoidonCreate(Bundle savedInstanceState) {
21.super.onCreate(savedInstanceState);
22.setContentView(R.layout.main);
23.reply= GetReply();
24.edtName= (EditText)this.findViewById(R.id.ed_name);
25.btnShow= (Button)this.findViewById(R.id.btn_show);
26.btnShow.setOnClickListener(newButton.OnClickListener() {
27.publicvoidonClick(View arg0) {
28.edtName.setText(reply);
29.}
30.});
31.}
32.}
packageorg.tonny.jni;

importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.view.View;
importandroid.widget.EditText;
importandroid.widget.Button;

{
static{
System.loadLibrary("JNITest");
}
privatenativeString GetReply();
privateEditTextedtName;
privateButtonbtnShow;
Stringreply;
/**Called when the activity is first created. */
@Override
publicvoidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
reply= GetReply();
edtName= (EditText)this.findViewById(R.id.ed_name);
btnShow= (Button)this.findViewById(R.id.btn_show);
btnShow.setOnClickListener(newButton.OnClickListener() {
publicvoidonClick(View arg0) {
edtName.setText(reply);
}
});
}
}

我們看這一段代碼：

[java] view plainprint?
01.static{
02.System.loadLibrary("JNITest");
03.}
static{
System.loadLibrary("JNITest");
}

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文件。

❽ JNI是什麼 android開發中必須要用到嗎

Android開發不難找工作，看能力，jni的學習需要知道c++或者c方面的知識，jni剛剛開始還是很難的，特別是javaVM和JNIEnv方面的知識得好好了解，還有有一些比較麻煩的就是java和c++有數據交互的情況下也麻煩一些，要建立相應的數據結構並且需要轉換，一般需要用到jni都是一些簡單的，比如java調c++或者c++調java之類的，涉及到多線程就麻煩些，得到了剛剛說的javavm以及jnienv