androidjni調試
⑴ android studio 項目在添加jni後,調試很慢
一、前提條件
1、Android studio版本最好2.0以上，在1.5上試過各種問題
2、Ndk版本最好是android-ndk-r10d，ndk的路徑要在項目根目錄下的local.properties下指定，例如ndk.dir=F:\android-ndk-r10d
二、加入gradle-experimental插件
1、打開項目根目錄下的build.gradle文件，加入
classpath "com.android.tools.build:gradle-experimental:0.7.0"
如下圖：
2、默認使用的是com.android.application這個插件，如果要進行jni調試最好換掉這個插件，也就是使用之前加入的gradle-experimental插件，據說不換好像也行，但是沒試過。下面貼出具體的配置：
[java]view plain
applyplugin:'com.android.model.application'
model{
android{
compileSdkVersion24
buildToolsVersion"24.0.2"
defaultConfig.with{
minSdkVersion.apiLevel=15
targetSdkVersion.apiLevel=24
applicationId"com.exampl.myapplication"
}
}
android.buildTypes{
release{
minifyEnabled=false
proguardFiles.add(file('proguard-rules.pro'))
}
}
android.ndk{
moleName="hello-jni"
ldLibs.addAll(["android","log"])
stl="gnustl_shared"
/*
*
*cppFlags.add("-fno-rtti")
*cppFlags.add("-fno-exceptions")
*ldLibs.addAll(["android","log"])
*stl="system"
*/
}
android.proctFlavors{
create("arm"){
ndk.abiFilters.add("armeabi")
}
create("arm7"){
ndk.abiFilters.add("armeabi-v7a")
}
create("arm8"){
ndk.abiFilters.add("arm64-v8a")
}
create("x86"){
ndk.abiFilters.add("x86")
}
create("x86-64"){
ndk.abiFilters.add("x86_64")
}
create("mips"){
ndk.abiFilters.add("mips")
}
create("mips-64"){
ndk.abiFilters.add("mips64")
}
//Toincludeallcpuarchitectures,leavesabiFiltersempty
create("all")
}
}
dependencies{
compilefileTree(dir:'libs',include:['*.jar'])
testCompile'junit:junit:4.12'
compile'com.android.support:appcompat-v7:24.1.1'
compile'com.android.support:design:24.1.1'
}
⑵ 如何在android的jni線程中實現回調
jni回調是指在c/c++代碼中調用java函數，當在c/c++的線程中執行回調函數時，會導致回調失敗。
其中一種在Android系統的解決方案是：
把c/c++中所有線程的創建，由pthread_create函數替換為由Java層的創建線程的函數AndroidRuntime::createJavaThread。
假設有c++函數:
[cpp] view plain
void *thread_entry(void *args)
{
while(1)
{
printf("thread running...\n");
sleep(1);
}
}
void init()
{
pthread_t thread;
pthread_create(&thread,NULL,thread_entry,(void *)NULL);
}
init()函數創建一個線程，需要在該線程中調用java類Test的回調函數Receive:
[cpp] view plain
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback:" + msg;
Log.d("Test", msg);
}
首先在c++中定義回調函數指針：
[cpp] view plain
//test.h
#include <pthread.h>
//function type for receiving data from native
typedef void (*ReceiveCallback)(unsigned char *buf, int len);
/** Callback for creating a thread that can call into the Java framework code.
* This must be used to create any threads that report events up to the framework.
*/
typedef pthread_t (* CreateThreadCallback)(const char* name, void (*start)(void *), void* arg);
typedef struct{
ReceiveCallback recv_cb;
CreateThreadCallback create_thread_cb;
}Callback;
再修改c++中的init和thread_entry函數：
[cpp] view plain
//test.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/wait.h>
#include <unistd.h>
#include "test.h"
void *thread_entry(void *args)
{
char *str = "i'm happy now";
Callback cb = NULL;
int len;
if(args != NULL){
cb = (Callback *)args;
}
len = strlen(str);
while(1)
{
printf("thread running...\n");
//invoke callback method to java
if(cb != NULL && cb->recv_cb != NULL){
cb->recv_cb((unsigned char*)str, len);
}
sleep(1);
}
}
void init(Callback *cb)
{
pthread_t thread;
//pthread_create(&thread,NULL,thread_entry,(void *)NULL);
if(cb != NULL && cb->create_thread_cb != NULL)
{
cb->create_thread_cb("thread",thread_entry,(void *)cb);
}
}
然後在jni中實現回調函數，以及其他實現：
[cpp] view plain
//jni_test.c
#include <stdlib.h>
#include <malloc.h>
#include <jni.h>
#include <JNIHelp.h>
#include "android_runtime/AndroidRuntime.h"
#include "test.h"
#define RADIO_PROVIDER_CLASS_NAME "com/tonny/Test"
using namespace android;
static jobject mCallbacksObj = NULL;
static jmethodID method_receive;
static void (JNIEnv* env, const char* methodName) {
if (env->ExceptionCheck()) {
LOGE("An exception was thrown by callback '%s'.", methodName);
LOGE_EX(env);
env->ExceptionClear();
}
}
static void receive_callback(unsigned char *buf, int len)
{
int i;
JNIEnv* env = AndroidRuntime::getJNIEnv();
jcharArray array = env->NewCharArray(len);
jchar *pArray ;
if(array == NULL){
LOGE("receive_callback: NewCharArray error.");
return;
}
pArray = (jchar*)calloc(len, sizeof(jchar));
if(pArray == NULL){
LOGE("receive_callback: calloc error.");
return;
}
// buffer to jchar array
for(i = 0; i < len; i++)
{
*(pArray + i) = *(buf + i);
}
// buffer to jcharArray
env->SetCharArrayRegion(array,0,len,pArray);
//invoke java callback method
env->CallVoidMethod(mCallbacksObj, method_receive,array,len);
//release resource
env->DeleteLocalRef(array);
free(pArray);
pArray = NULL;
(env, __FUNCTION__);
}
static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
{
return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
}
static Callback mCallbacks = {
receive_callback,
create_thread_callback
};
static void jni_class_init_native
(JNIEnv* env, jclass clazz)
{
method_receive = env->GetMethodID(clazz, "Receive", "([CI)V");
}
static int jni_init
(JNIEnv *env, jobject obj)
{
if (!mCallbacksObj)
mCallbacksObj = env->NewGlobalRef(obj);
return init(&mCallbacks);
}
static const JNINativeMethod gMethods[] = {
{ "class_init_native", "()V", (void *)jni_class_init_native },
{ "native_init", "()I", (void *)jni_init },
};
static int registerMethods(JNIEnv* env) {
const char* const kClassName = RADIO_PROVIDER_CLASS_NAME;
jclass clazz;
/* look up the class */
clazz = env->FindClass(kClassName);
if (clazz == NULL) {
LOGE("Can't find class %s/n", kClassName);
return -1;
}
/* register all the methods */
if (env->RegisterNatives(clazz,gMethods,sizeof(gMethods)/sizeof(gMethods[0])) != JNI_OK)
{
LOGE("Failed registering methods for %s/n", kClassName);
return -1;
}
/* fill out the rest of the ID cache */
return 0;
}
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
LOGI("Radio JNI_OnLoad");
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed/n");
goto fail;
}
if(env == NULL){
goto fail;
}
if (registerMethods(env) != 0) {
LOGE("ERROR: PlatformLibrary native registration failed/n");
goto fail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
fail:
return result;
}
jni的Android.mk文件中共享庫設置為：
[cpp] view plain
LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper
最後再實現Java中的Test類：
[java] view plain
//com.tonny.Test.java
public class Test {
static{
try {
System.loadLibrary("test");
class_init_native();
} catch(UnsatisfiedLinkError ule){
System.err.println("WARNING: Could not load library libtest.so!");
}
}
public int initialize() {
return native_radio_init();
}
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback" + msg;
Log.d("Test", msg);
}
protected static native void class_init_native();
protected native int native_init();
}
⑶ 如何調試android NDK 交叉編譯的cpp文件
主要講一下具體的步驟，具體的ndk指令我就不說了，貼的文章都有：
首先是寫一個.java文件，本例中是HprofDumper.java
具體如下：
public class HprofDumper {
public native boolean hprofDumper(String filename, String outname);
}
然後用命令javac HprofDumper.java 生成.class文件
再用javah HprofDumper 生成相應的.h文件
生成的.h文件如下
#include
#ifndef _Included_HprofDumper
#define _Included_HprofDumper
#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT jboolean JNICALL Java_HprofDumper_hprofDumper
(JNIEnv *, jobject, jstring, jstring);
#ifdef __cplusplus
}
#endif
#endif
然後只需要在對應的.cpp文件完成相應函數即可，核心代碼如下：
#include "HprofDumper.h"
#include "hprof.h"
JNIEXPORT jboolean JNICALL Java_HprofDumper_hprofDumper
(JNIEnv *env, jobject obj, jstring in_file, jstring out_file)
{
const char *filename = env->GetStringUTFChars(in_file, 0);
const char *outname = env->GetStringUTFChars(out_file, 0);
return hprof_mp(filename, outname);
}
其中hprof_mp是純c++代碼，引入即可。
有一點需要注意，標紅了已經，就是生成的.h文件函數並沒具體形參名字，只有形參類型，在.cpp文件中要加入相應的形參名字，本例為env、 obj、 in_file和out_file。
還有一點c和c++的區別，就是env的使用。
本例中C++為env->GetStringUTFChars(in_file, 0);
如果是C就應該改為(env)->GetStringUTFChars(env,in_file, 0);
調用Java類型 : C中調用Java中的String類型為 jstring;
C語言方法名規則 : Java_完整包名類名_方法名(JNIEnv *env, jobject thiz), 注意完整的類名包名中包名的點要用 _ 代替;
參數介紹 : C語言方法中有兩個重要的參數, JNIEnv *env, jobject thiz ;
-- JNIEnv參數 : 該參數代表Java環境, 通過這個環境可以調用Java中的方法;
-- jobject參數 : 該參數代表調用jni方法的類,;
調用jni.h中的NewStringUTF方法 : 該方法的作用是在C語言中創建一個Java語言中的String類型對象, jni.h中是這樣定義的 jstring (*NewStringUTF)(JNIEnv*, const char*), JNIEnv 結構體中包含了 NewStringUTF 函數指針, 通過 JNIEnv 就可以調用這個方法;
完成代碼編寫後，在當前目錄下完成Android.mk和Application.mk的編寫
首先是Android.mk
本例中為：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := hprof-mper
LOCAL_C_INCLUDES += external/stlport/stlport
LOCAL_C_INCLUDES += bionic
LOCAL_C_INCLUDES += bionic/libstdc++/include
LOCAL_SRC_FILES := HprofDumper.cpp \
xx.cpp \
xx.cpp \
xx.cpp \
xx.cpp \
xx.cpp \
xx.cpp \
xxx.cpp
LOCAL_SHARED_LIBRARIES := libstlport
include $(BUILD_SHARED_LIBRARY)
注意標紅的是最關鍵的，LOCAL_C_INCLUDES 顧名思義是需要的頭文件的所在的目錄，那三個參數主要為了引入STL，最重要！！LOCAL_SHARED_LIBRARIES 我一直生成失敗就是沒加這個參數，不光要引入頭文件，還要引入具體的lib，這就是這個欄位的作用。
具體欄位的作用：
-- LOCAL_PATH : 代表mk文件所在的目錄;
-- include $(CLEAR_VARS) : 編譯工具函數, 通過該函數可以進行一些初始化操作;
-- LOCAL_MODULE : 編譯後的 .so 後綴文件叫什麼名字;
-- LOCAL_SRC_FILES: 指定編譯的源文件名稱;
-- include $(BUILD_SHARED_LIBRARY) : 告訴編譯器需要生成動態庫;
Applicaion.mk中就一行
APP_STL = stlport_static
表示使用stl靜態庫。
注意：我用了STL，大家沒有用STL的當然不用引入這些啦~
⑷ 如何在android的jni線程中實現回調
JNI回調是指在c/c++代碼中調用java函數，當在c/c++的線程中執行回調函數時，會導致回調失敗。
其中一種在Android系統的解決方案是：
把c/c++中所有線程的創建，由pthread_create函數替換為由Java層的創建線程的函數AndroidRuntime::createJavaThread。
假設有c++函數:
[cpp] view plain
void *thread_entry(void *args)
{
while(1)
{
printf("thread running...\n");
sleep(1);
}
}
void init()
{
pthread_t thread;
pthread_create(&thread,NULL,thread_entry,(void *)NULL);
}
init()函數創建一個線程，需要在該線程中調用java類Test的回調函數Receive:
[cpp] view plain
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback:" + msg;
Log.d("Test", msg);
}
首先在c++中定義回調函數指針：
[cpp] view plain
//test.h
#include <pthread.h>
//function type for receiving data from native
typedef void (*ReceiveCallback)(unsigned char *buf, int len);
/** Callback for creating a thread that can call into the Java framework code.
* This must be used to create any threads that report events up to the framework.
*/
typedef pthread_t (* CreateThreadCallback)(const char* name, void (*start)(void *), void* arg);
typedef struct{
ReceiveCallback recv_cb;
CreateThreadCallback create_thread_cb;
}Callback;
再修改c++中的init和thread_entry函數：
[cpp] view plain
//test.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/wait.h>
#include <unistd.h>
#include "test.h"
void *thread_entry(void *args)
{
char *str = "i'm happy now";
Callback cb = NULL;
int len;
if(args != NULL){
cb = (Callback *)args;
}
len = strlen(str);
while(1)
{
printf("thread running...\n");
//invoke callback method to java
if(cb != NULL && cb->recv_cb != NULL){
cb->recv_cb((unsigned char*)str, len);
}
sleep(1);
}
}
void init(Callback *cb)
{
pthread_t thread;
//pthread_create(&thread,NULL,thread_entry,(void *)NULL);
if(cb != NULL && cb->create_thread_cb != NULL)
{
cb->create_thread_cb("thread",thread_entry,(void *)cb);
}
}
然後在jni中實現回調函數，以及其他實現：
[cpp] view plain
//jni_test.c
#include <stdlib.h>
#include <malloc.h>
#include <jni.h>
#include <JNIHelp.h>
#include "android_runtime/AndroidRuntime.h"
#include "test.h"
#define RADIO_PROVIDER_CLASS_NAME "com/tonny/Test"
using namespace android;
static jobject mCallbacksObj = NULL;
static jmethodID method_receive;
static void (JNIEnv* env, const char* methodName) {
if (env->ExceptionCheck()) {
LOGE("An exception was thrown by callback '%s'.", methodName);
LOGE_EX(env);
env->ExceptionClear();
}
}
static void receive_callback(unsigned char *buf, int len)
{
int i;
JNIEnv* env = AndroidRuntime::getJNIEnv();
jcharArray array = env->NewCharArray(len);
jchar *pArray ;
if(array == NULL){
LOGE("receive_callback: NewCharArray error.");
return;
}
pArray = (jchar*)calloc(len, sizeof(jchar));
if(pArray == NULL){
LOGE("receive_callback: calloc error.");
return;
}
// buffer to jchar array
for(i = 0; i < len; i++)
{
*(pArray + i) = *(buf + i);
}
// buffer to jcharArray
env->SetCharArrayRegion(array,0,len,pArray);
//invoke java callback method
env->CallVoidMethod(mCallbacksObj, method_receive,array,len);
//release resource
env->DeleteLocalRef(array);
free(pArray);
pArray = NULL;
(env, __FUNCTION__);
}
static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
{
return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
}
static Callback mCallbacks = {
receive_callback,
create_thread_callback
};
static void jni_class_init_native
(JNIEnv* env, jclass clazz)
{
method_receive = env->GetMethodID(clazz, "Receive", "([CI)V");
}
static int jni_init
(JNIEnv *env, jobject obj)
{
if (!mCallbacksObj)
mCallbacksObj = env->NewGlobalRef(obj);
return init(&mCallbacks);
}
static const JNINativeMethod gMethods[] = {
{ "class_init_native", "()V", (void *)jni_class_init_native },
{ "native_init", "()I", (void *)jni_init },
};
static int registerMethods(JNIEnv* env) {
const char* const kClassName = RADIO_PROVIDER_CLASS_NAME;
jclass clazz;
/* look up the class */
clazz = env->FindClass(kClassName);
if (clazz == NULL) {
LOGE("Can't find class %s/n", kClassName);
return -1;
}
/* register all the methods */
if (env->RegisterNatives(clazz,gMethods,sizeof(gMethods)/sizeof(gMethods[0])) != JNI_OK)
{
LOGE("Failed registering methods for %s/n", kClassName);
return -1;
}
/* fill out the rest of the ID cache */
return 0;
}
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
LOGI("Radio JNI_OnLoad");
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed/n");
goto fail;
}
if(env == NULL){
goto fail;
}
if (registerMethods(env) != 0) {
LOGE("ERROR: PlatformLibrary native registration failed/n");
goto fail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
fail:
return result;
}
jni的Android.mk文件中共享庫設置為：
[cpp] view plain
LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper
最後再實現Java中的Test類：
[java] view plain
//com.tonny.Test.java
public class Test {
static{
try {
System.loadLibrary("test");
class_init_native();
} catch(UnsatisfiedLinkError ule){
System.err.println("WARNING: Could not load library libtest.so!");
}
}
public int initialize() {
return native_radio_init();
}
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback" + msg;
Log.d("Test", msg);
}
protected static native void class_init_native();
protected native int native_init();
}
⑸ 如何在Android下使用JNI
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等。
NDK編譯步驟：
1.選擇 ndk 自帶的例子 hello-jni ，我的位於E:\android-ndk-r5\samples\hello-jni( 根據具體的安裝位置而定 ) 。
2.運行 cygwin ，輸入命令 cd /cygdrive/e/android-ndk-r5/samples/hello-jni ，進入到 E:\android-ndk-r5\samples\hello-jni 目錄。
3.輸入 $NDK/ndk-build ，執行成功後，它會自動生成一個 libs 目錄，把編譯生成的 .so 文件放在裡面。 ($NDK是調用我們之前配置好的環境變數， ndk-build 是調用 ndk 的編譯程序 )
4.此時去 hello-jni 的 libs 目錄下看有沒有生成的 .so 文件，如果有，ndk 就運行正常啦。
⑹ 如何在android的jni線程中實現回調
JNI回調是指在c/c++代碼中調用java函數，當在c/c++的線程中執行回調函數時，會導致回調失敗。 其中一種在Android系統的解決方案是： 把c/c++中所有線程的創建，由pthread_create函數替換為由Java層的創建線程的函數AndroidRuntime::createJavaThread。 假設有c++函數: [cpp] view plain void *thread_entry(void *args) { while(1) { printf("thread running...\n"); sleep(1); } } void init() { pthread_t thread; pthread_create(&thread,NULL,thread_entry,(void *)NULL); } init()函數創建一個線程，需要在該線程中調用java類Test的回調函數Receive: [cpp] view plain public void Receive(char buffer[],int length){ String msg = new String(buffer); msg = "received from jni callback:" + msg; Log.d("Test", msg); } 首先在c++中定義回調函數指針： [cpp] view plain //test.h #include <pthread.h> //function type for receiving data from native typedef void (*ReceiveCallback)(unsigned char *buf, int len); /** Callback for creating a thread that can call into the Java framework code. * This must be used to create any threads that report events up to the framework. */ typedef pthread_t (* CreateThreadCallback)(const char* name, void (*start)(void *), void* arg); typedef struct{ ReceiveCallback recv_cb; CreateThreadCallback create_thread_cb; }Callback; 再修改c++中的init和thread_entry函數： [cpp] view plain //test.c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <sys/wait.h> #include <unistd.h> #include "test.h" void *thread_entry(void *args) { char *str = "i'm happy now"; Callback cb = NULL; int len; if(args != NULL){ cb = (Callback *)args; } len = strlen(str); while(1) { printf("thread running...\n"); //invoke callback method to java if(cb != NULL && cb->recv_cb != NULL){ cb->recv_cb((unsigned char*)str, len); } sleep(1); } } void init(Callback *cb) { pthread_t thread; //pthread_create(&thread,NULL,thread_entry,(void *)NULL); if(cb != NULL && cb->create_thread_cb != NULL) { cb->create_thread_cb("thread",thread_entry,(void *)cb); } } 然後在jni中實現回調函數，以及其他實現： [cpp] view plain //jni_test.c #include <stdlib.h> #include <malloc.h> #include <jni.h> #include <JNIHelp.h> #include "android_runtime/AndroidRuntime.h" #include "test.h" #define RADIO_PROVIDER_CLASS_NAME "com/tonny/Test" using namespace android; static jobject mCallbacksObj = NULL; static jmethodID method_receive; static void (JNIEnv* env, const char* methodName) { if (env->ExceptionCheck()) { LOGE("An exception was thrown by callback '%s'.", methodName); LOGE_EX(env); env->ExceptionClear(); } } static void receive_callback(unsigned char *buf, int len) { int i; JNIEnv* env = AndroidRuntime::getJNIEnv(); jcharArray array = env->NewCharArray(len); jchar *pArray ; if(array == NULL){ LOGE("receive_callback: NewCharArray error."); return; } pArray = (jchar*)calloc(len, sizeof(jchar)); if(pArray == NULL){ LOGE("receive_callback: calloc error."); return; } // buffer to jchar array for(i = 0; i < len; i++) { *(pArray + i) = *(buf + i); } // buffer to jcharArray env->SetCharArrayRegion(array,0,len,pArray); //invoke java callback method env->CallVoidMethod(mCallbacksObj, method_receive,array,len); //release resource env->DeleteLocalRef(array); free(pArray); pArray = NULL; (env, __FUNCTION__); } static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg) { return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg); } static Callback mCallbacks = { receive_callback, create_thread_callback }; static void jni_class_init_native (JNIEnv* env, jclass clazz) { method_receive = env->GetMethodID(clazz, "Receive", "([CI)V"); } static int jni_init (JNIEnv *env, jobject obj) { if (!mCallbacksObj) mCallbacksObj = env->NewGlobalRef(obj); return init(&mCallbacks); } static const JNINativeMethod gMethods[] = { { "class_init_native", "()V", (void *)jni_class_init_native }, { "native_init", "()I", (void *)jni_init }, }; static int registerMethods(JNIEnv* env) { const char* const kClassName = RADIO_PROVIDER_CLASS_NAME; jclass clazz; /* look up the class */ clazz = env->FindClass(kClassName); if (clazz == NULL) { LOGE("Can't find class %s/n", kClassName); return -1; } /* register all the methods */ if (env->RegisterNatives(clazz,gMethods,sizeof(gMethods)/sizeof(gMethods[0])) != JNI_OK) { LOGE("Failed registering methods for %s/n", kClassName); return -1; } /* fill out the rest of the ID cache */ return 0; } jint JNI_OnLoad(JavaVM* vm, void* reserved) { JNIEnv* env = NULL; jint result = -1; LOGI("Radio JNI_OnLoad"); if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { LOGE("ERROR: GetEnv failed/n"); goto fail; } if(env == NULL){ goto fail; } if (registerMethods(env) != 0) { LOGE("ERROR: PlatformLibrary native registration failed/n"); goto fail; } /* success -- return valid version number */ result = JNI_VERSION_1_4; fail: return result; } jni的Android.mk文件中共享庫設置為： [cpp] view plain LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper 最後再實現Java中的Test類： [java] view plain //com.tonny.Test.java public class Test { static{ try { System.loadLibrary("test"); class_init_native(); } catch(UnsatisfiedLinkError ule){ System.err.println("WARNING: Could not load library libtest.so!"); } } public int initialize() { return native_radio_init(); } public void Receive(char buffer[],int length){ String msg = new String(buffer); msg = "received from jni callback" + msg; Log.d("Test", msg); } protected static native void class_init_native(); protected native int native_init(); }
⑺ 如何在Android下使用JNI
關於如何在Android使用JNI調用C/C++代碼庫，網上已經有很多優秀的文章了，這里說一個大概過程吧：
首先需要懂C，其次要明白JNI的開發流程，然後還要知道NDK如何使用
1、在java代碼中聲明了一個native本地方法
Public native String helloFromc();
2、在項目目錄中創建JNI文件夾
3、在JNI文件夾裡面創建C文件，按照規范寫代碼
Jstring
Java_com_cheng_jnitest_MainActivity_helloFromc(JNIEnv* env,jobject obj)
4、用ndk-build指令編譯
編譯前需要配置Android.mk文件
//指定編譯的文件夾，指定當前的目錄
LOCAL_PATH := $(call my-dir)
//編譯器在編譯的時候會產生很多臨時變數，中間變數最好在編譯前清空所有的臨時變數
include $(CLEAR_VARS)
//編譯完成後的模塊名
LOCAL_MOUDLE := hello
//編譯的源文件
LOCAL_SRC_FILES:=hello.c
//編譯一個動態庫
//動態庫.so 只包含運行的函數，不包含依賴，所以體積小，運行的時候回去系統尋找依賴
//靜態庫.a 包含所有的函數和運行的依賴，所以體積大，包含所有的api
include $(BUILD_SHARED_LIBRARY)
5、生成了一個so動態庫，放到了libs裡面
6、項目中引入依賴庫
Static{
System.loadLibrary("hello");
}
⑻ Android-NDK：JNI本地文件中怎麼調試列印輸出到LOGCAT
加入頭文件
#include <android/log.h>
函數__android_log_print(ANDROID_LOG_INFO,LOG_TAG,TITLE)
第一個參數ANDROID_LOG_INFO（還有ANDROID_LOG_ERROR等），表示什麼類型
的輸出，上面的函數相當於android的java代碼的Log.i(LOG_TAG,TITLE),第二個參數就是logcat里的tag，第三個就是列印的內容。具體的請到log.h中自己查看。
Android之NDK開發
一、NDK產生的背景
Android平台從誕生起，就已經支持C、C++開發。眾所周知，Android的SDK基於Java實現，這意味著基於Android SDK進行開發的第三方應用都必須使用Java語言。但這並不等同於「第三方應用只能使用Java」。在Android SDK首次發布時，Google就宣稱其虛擬機Dalvik支持JNI編程方式，也就是第三方應用完全可以通過JNI調用自己的C動態庫，即在Android平台上，「Java+C」的編程方式是一直都可以實現的。
不過，Google也表示，使用原生SDK編程相比Dalvik虛擬機也有一些劣勢，Android SDK文檔里，找不到任何JNI方面的幫助。即使第三方應用開發者使用JNI完成了自己的C動態鏈接庫（so）開發，但是so如何和應用程序一起打包成apk並發布？這裡面也存在技術障礙。比如程序更加復雜，兼容性難以保障，無法訪問Framework API，Debug難度更大等。開發者需要自行斟酌使用。
於是NDK就應運而生了。NDK全稱是Native Development Kit。
NDK的發布，使「Java+C」的開發方式終於轉正，成為官方支持的開發方式。NDK將是Android平台支持C開發的開端。
二、為什麼使用NDK
1.代碼的保護。由於apk的java層代碼很容易被反編譯，而C/C++庫反匯難度較大。
2.可以方便地使用現存的開源庫。大部分現存的開源庫都是用C/C++代碼編寫的。
3.提高程序的執行效率。將要求高性能的應用邏輯使用C開發，從而提高應用程序的執行效率。
4.便於移植。用C/C++寫得庫可以方便在其他的嵌入式平台上再次使用。
三、NDK簡介
1.NDK是一系列工具的集合
NDK提供了一系列的工具，幫助開發者快速開發C（或C++）的動態庫，並能自動將so和java應用一起打包成apk。這些工具對開發者的幫助是巨大的。
NDK集成了交叉編譯器，並提供了相應的mk文件隔離CPU、平台、ABI等差異，開發人員只需要簡單修改mk文件（指出「哪些文件需要編譯」、「編譯特性要求」等），就可以創建出so。
NDK可以自動地將so和Java應用一起打包，極大地減輕了開發人員的打包工作。
2.NDK提供了一份穩定、功能有限的API頭文件聲明
Google明確聲明該API是穩定的，在後續所有版本中都穩定支持當前發布的API。從該版本的NDK中看出，這些API支持的功能非常有限，包含有：C標准庫（libc）、標准數學庫（libm）、壓縮庫（libz）、Log庫（liblog）。
⑼ 如何使用android framework 中的串口jni
網路上搜索「串口調試助手」或者「串口調試精靈」，進行簡單的安裝。 點擊運行串口調試助手，進入相應的界面。 設置串口通訊的介面，波特率校驗位等相關信息。 在發送欄輸入要發送的信息，選擇手動發送或者自動發送，這時如果沒有什麼錯誤，對方的串口通信工具就會收到發送的內容。 設置接收區域的相關信息，這時對方如果發送信息，接收區就會收到相應的內容。 另外也可以進行文件的發送，但是串口通信的速率過慢，傳輸文件的話會很耗時，不過可以用來檢測通信的正確性。
⑽ 如何實現在android studio中附加模式調試app
我在學習的過程中，親歷的這件事：項目組要做一個復雜的工程，分為sdk工程和demo工程，裡面有java和jni層
而so和aar是sdk工程中生成的，拷貝到demo工程中編譯成最終apk。
java層的調試，是簡單的。可以在運行的時候用sdk工程的android studio附加app，如果直接用demo附加，sdk中的源碼有些並不好顯現，只能通過工程目錄jar文件來查看。
而so層的附加，默認情況下是不可行的，因為jni層調試是啟動型調試，我們來看下android studio處理各種調試行為的過程：
java層調試：
adb push 1.apk /data/local/tmp/1.apk
am start -D -n com.example.test/.MainActivity
android studio等待app狀態正常
設置斷點
執行remote connect，使用java調試協議附加
jni層調試：
adb push 1.apk /data/local/tmp/1.apk
am start -D -n com.example.test/.MainActivity
android studio等待app狀態正常
adb push lldb_server
./lldb_server ..............建立Lldb調試伺服器
lldbfrontend.exe ...........連接lldb調試伺服器
向lldb_server發送附加調試命令
設置java/c層斷點
執行remote connect，使用java調試協議附加
附加調試：
設置斷點
執行remote connect，使用java調試協議附加
1.在研究過程中發現jni層在編譯時生成2個so，帶符號的是obj/local目錄下的so，apk中編譯好的的so是可以不帶符號的，此時用gdb調試，吧文件設置為帶符號的so，即可調試。繼續研究發現帶符號的so和無符號的so，前面位元組完全相同。
2.android studio建立jni工程，需要自動安裝lldb，修改gradle腳本，build.gradle
debug {
jniDebuggable true
}
3.android studio附加按鈕只是採用Run/Debug Configuration中的Remote Configuaration
從上述過程可見，附加並不能觸發jni層調試步驟，而jni層調試步驟又是寫死的，必須把前面載入apk部分去掉，於是對android-ndk.jar做修改
最終實現了效果。其中一些重要的類：
IDevice：描述移動設備
Client：描述app包進程
AndroidNativeDebugProcess 控制jni調試，和lldb_server通信
AndroidNativeDeubgRunner 控制調試器部分
AndroidNativeRunConfiguration 配置Run/Debug Configuration中的Natvie-Debug選項，我在裡面添加了用戶app進程列表方便調試
配置界面控制項
AndroidLLDBDebuggerContext jni層建立lldb調試器
AndroidLLDBDriver 實現基本調試功能