安卓机普遍会有备份通讯录的功能，备份的文件一般存储在内存卡中具体那个文件夹视手机而定，如果你的Java无系统手机有导入通讯录备份的功能，并且导入备份的文件支持你安卓机导出的备份文件，这样你把安卓机备份的通讯录文件拷贝到java无系统手机的内存卡中，直接导入通讯录备份文件。不过这个只是我的猜想，我没有试过，但是大胆的猜测下，不可行的几率会大些。 ----------------哥割哥---------------- 楼上的方法也许更值得一试。
B. 如何在android源码中添加自己的jni方法
1,、项目实现了一个简单的四则运算，项目的目录层次如下：
AndroidManifest.xml Android.mk jni res src
资源文件简简单单，一个布局文件，稍后会有demo的下载地址
主要记录备忘的内容如下：
MainActivity.Java
[html] view plain public native int add(int x, int y);
public native int substraction(int x, int y);
public native float multiplication(int x, int y);
public native float division(int x, int y);
static{
System.loadLibrary("arithmetic");
}
2、生成lib的名称为libarithmetic.so.注意load的时候写"arithmetic"
jni 目录下有两个文件，一个是Android.mk,一个是c++源文件long.cpp
jni/Android.mk如下：
[html] view plain LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE:= libarithmetic
LOCAL_SRC_FILES:= \
long.cpp
LOCAL_SHARED_LIBRARIES := \
libutils
LOCAL_STATIC_LIBRARIES :=
LOCAL_C_INCLUDES += \
$(JNI_H_INCLUDE)
LOCAL_CFLAGS +=
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)
3、注释：
LOCAL_PATH(必须定义，而且要第一个定义)，宏函数‘my-dir’, 由编译系统提供，用于返回当前路径(即包含Android.mk
file文件的目录);
include $( CLEAR_VARS)，
CLEAR_VARS由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量(例如 LOCAL_MODULE,
LOCAL_SRC_FILES, LOCAL_STATIC_LIBRARIES, 等等...),除LOCAL_PATH
。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的;
LOCAL_MODULE_TAGS ：=user eng tests optional
user: 指该模块只在user版本下才编译
eng: 指该模块只在eng版本下才编译
tests: 指该模块只在tests版本下才编译
optional:指该模块在所有版本下都编译
LOCAL_MODULE(必须定义)，标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。Note:编译系统会自动产生合适的前缀和后缀,例如：arithmetic编译成功后将生成libarithmetic.so库文件
LOCAL_SRC_FILES 变量必须包含将要编译打包进模块中源代码文件。不用在这里列出头文件和包含文件。
LOCAL_SHARED_LIBRARIES中加入所需要链接的动态库(*.so)的名称
LOCAL_STATIC_LIBRARIES加入所需要链接的静态库(*.a)的名称
LOCAL_CFLAG可选的编译器选项，用法之一是定义宏,例如LOCAL_CFLAGS := -Werror作用是编译警告也作为错误信息
LOCAL_PRELINK_MODULE:=false,不作prelink处理，默认是要prelink操作的，有可能造成地址空间冲突(这地方目前还不明白)
long.cpp源代码如下：
[html] view plain #define LOG_TAG "LongTest2 long.cpp"
#include
#include
#include "jni.h"
jint add(JNIEnv *env, jobject thiz, jint x, jint y){
return x + y;
}
jint substraction(JNIEnv *env, jobject thiz, jint x, jint y){
return x - y;
}
jfloat multiplication(JNIEnv *env, jobject thiz, jint x, jint y){
return (float)x * (float)y;
}
jfloat division(JNIEnv *env, jobject thiz, jint x, jint y){
return (float)x/(float)y;
}
static const char *classPathName = "com/inspur/test2/MainActivity";
static JNINativeMethod methods[]= {
{"add", "(II)I", (void*)add},
{"substraction", "(II)I", (void*)substraction},
{"multiplication", "(II)F", (void*)multiplication},
{"division", "(II)F", (void*)division},
};
typedef union{
JNIEnv* env;
void* venv;
}UnionJNIEnvToVoid;
static int registerNativeMethods(JNIEnv* env, const char* className,
JNINativeMethod* gMethods, int numMethods){
jclass clazz;
clazz = env->FindClass(className);
if (clazz == NULL)
return JNI_FALSE;
if (env->RegisterNatives(clazz, gMethods, numMethods)<0)
return JNI_FALSE;
return JNI_TRUE;
}
static int registerNatives(JNIEnv *env){
if (!registerNativeMethods(env, classPathName,
methods, sizeof(methods)/sizeof(methods[0])))
{
return JNI_FALSE;
}
return JNI_TRUE;
}
jint JNI_OnLoad(JavaVM* vm, void* reserved){
UnionJNIEnvToVoid uenv;
uenv.venv = NULL;
jint result = -1;
JNIEnv *env = NULL;
if (vm->GetEnv(&uenv.venv, JNI_VERSION_1_4) != JNI_OK){
goto l;
}
env = uenv.env;
env = uenv.env;
if (registerNatives(env) != JNI_TRUE){
goto l;
}
result = JNI_VERSION_1_4;
l:
return result;
}
除了利用 编写native JAVA类，通过javah生成.h文件，根据.h文件编写.c/cpp文件
方法外(名字像老太太的裹脚步，又臭又长，而且不灵活)，Android还可以通过引用JNI_Onload方式实现。jint JNI_onLoad(JavaVM*
vm, void* reverced),改方法在so文件被加载时调用。
JNI_OnLoad()有两个重要的作用：
指定JNI版本：告诉VM该组件使用那一个JNI版本(若未提供JNI_OnLoad()函数，VM会默认该使用最老的JNI
1.1版)，如果要使用新版本的JNI，例如JNI
1.4版，则必须由JNI_OnLoad()函数返回常量JNI_VERSION_1_4(该常量定义在jni.h中) 来告知VM。
初始化设定，当VM执行到System.loadLibrary()函数时，会立即先呼叫JNI_OnLoad()方法，因此在该方法中进行各种资源的初始化操作最为恰当。
JNI_OnUnload()的作用与JNI_OnLoad()对应，当VM释放JNI组件时会呼叫它，因此在该方法中进行善后清理，资源释放的动作最为合适。
4、项目根目录下Android.mk文件：
[html] view plain LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := $(call all-java-files-under, src)
LOCAL_JNI_SHARED_LIBRARIES := libarithmetic
LOCAL_PACKAGE_NAME := LongTest
LOCAL_SHARED_LIBRARIES := \
libutils\
liblog
include $(BUILD_PACKAGE)
include $(LOCAL_PATH)/jni/Android.mk
# Also build all of the sub-targets under this one: the shared library.
include $(call all-makefiles-under,$(LOCAL_PATH))
LOCAL_PACKAGE_NAME：项目名称，即最终生成apk的名字
LOCAL_JNI_SHARED_LIBRARIES := libxxx就是把so文件放到apk文件里的libs/armeabi里
执行BUILD_PACKAGE。它的定义也是在config.mk中定义如下：BUILD_PACKAGE:=
$(BUILD_SYSTEM)/package.mk
$(call all-java-files-under, src)编译的源代码文件列表添加src目录下所有的java 源文件
$(call all-makefiles-under, $(LOCAL_PATH))编译器会在编译完当前目录下的文件后再深入子目录编译
如果make过android源码，可以在项目根目录下执行mm命令进行编译。前提是执行过source
androidSRC/build/envsetup.sh
或者直接把source androidSRC/build/envsetup.sh添加到~/.bashrc中，会更加方便
C. android应用是如何监听自己是否被卸载的呢
Activity启动时fork出C端进程轮询目录：
1 package main.activity;
2
3 import pym.test.uninstalledmoniter.R;
4 import android.app.Activity;
5 import android.os.Bundle;
6 import android.util.Log;
7
8 /**
9 * @author pengyiming
10 * @note 监听此应用是否被卸载，若被卸载则弹出卸载反馈
11 *
12 */
13
14 public class UninstalledMoniterActivity extends Activity
15 {
16 /* 数据段begin */
17 private static final String TAG = "UninstalledMoniterActivity";
18 /* 数据段end */
19
20 /* 函数段begin */
21 private native void init();
22 static
23 {
24 Log.d(TAG, "load libuninstalled_moniter");
25 System.loadLibrary("uninstalled_moniter");
26 }
27
28 @Override
29 public void onCreate(Bundle savedInstanceState)
30 {
31 super.onCreate(savedInstanceState);
32 Log.d(TAG, "onCreate");
33
34 setContentView(R.layout.uninstalled_moniter_layout);
35
36 init();
37 }
38 /* 函数段end */
39 }
核心——native方法头文件：
1 /* 头文件begin */
2 #include <jni.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <android/log.h>
6 #include <unistd.h>
7 /* 头文件end */
8
9 /* 宏定义begin */
10 //清0宏
11 #define MEM_ZERO(pDest, destSize) memset(pDest, 0, destSize)
12
13 //LOG宏定义
14 #define LOG_INFO(tag, msg) __android_log_write(ANDROID_LOG_INFO, tag, msg)
15 #define LOG_DEBUG(tag, msg) __android_log_write(ANDROID_LOG_DEBUG, tag, msg)
16 #define LOG_WARN(tag, msg) __android_log_write(ANDROID_LOG_WARN, tag, msg)
17 #define LOG_ERROR(tag, msg) __android_log_write(ANDROID_LOG_ERROR, tag, msg)
18 /* 宏定义end */
19
20 #ifndef _Included_main_activity_UninstalledMoniterActivity
21 #define _Included_main_activity_UninstalledMoniterActivity
22 #ifdef __cplusplus
23 extern "C" {
24 #endif
25
26 #undef main_activity_UninstalledMoniterActivity_MODE_PRIVATE
27 #define main_activity_UninstalledMoniterActivity_MODE_PRIVATE 0L
28 #undef main_activity_UninstalledMoniterActivity_MODE_WORLD_READABLE
29 #define main_activity_UninstalledMoniterActivity_MODE_WORLD_READABLE 1L
30 #undef main_activity_UninstalledMoniterActivity_MODE_WORLD_WRITEABLE
31 #define main_activity_UninstalledMoniterActivity_MODE_WORLD_WRITEABLE 2L
32 #undef main_activity_UninstalledMoniterActivity_MODE_APPEND
33 #define main_activity_UninstalledMoniterActivity_MODE_APPEND 32768L
34 #undef main_activity_UninstalledMoniterActivity_MODE_MULTI_PROCESS
35 #define main_activity_UninstalledMoniterActivity_MODE_MULTI_PROCESS 4L
36 #undef main_activity_UninstalledMoniterActivity_BIND_AUTO_CREATE
37 #define main_activity_UninstalledMoniterActivity_BIND_AUTO_CREATE 1L
38 #undef main_activity_UninstalledMoniterActivity_BIND_DEBUG_UNBIND
39 #define main_activity_UninstalledMoniterActivity_BIND_DEBUG_UNBIND 2L
40 #undef main_activity_UninstalledMoniterActivity_BIND_NOT_FOREGROUND
41 #define main_activity_UninstalledMoniterActivity_BIND_NOT_FOREGROUND 4L
42 #undef main_activity_UninstalledMoniterActivity_BIND_ABOVE_CLIENT
43 #define main_activity_UninstalledMoniterActivity_BIND_ABOVE_CLIENT 8L
44 #undef main_activity_UninstalledMoniterActivity_BIND_ALLOW_OOM_MANAGEMENT
45 #define main_activity_UninstalledMoniterActivity_BIND_ALLOW_OOM_MANAGEMENT 16L
46 #undef main_activity_UninstalledMoniterActivity_BIND_WAIVE_PRIORITY
47 #define main_activity_UninstalledMoniterActivity_BIND_WAIVE_PRIORITY 32L
48 #undef main_activity_UninstalledMoniterActivity_BIND_IMPORTANT
49 #define main_activity_UninstalledMoniterActivity_BIND_IMPORTANT 64L
50 #undef main_activity_UninstalledMoniterActivity_BIND_ADJUST_WITH_ACTIVITY
51 #define main_activity_UninstalledMoniterActivity_BIND_ADJUST_WITH_ACTIVITY 128L
52 #undef main_activity_UninstalledMoniterActivity_CONTEXT_INCLUDE_CODE
53 #define main_activity_UninstalledMoniterActivity_CONTEXT_INCLUDE_CODE 1L
54 #undef main_activity_UninstalledMoniterActivity_CONTEXT_IGNORE_SECURITY
55 #define main_activity_UninstalledMoniterActivity_CONTEXT_IGNORE_SECURITY 2L
56 #undef main_activity_UninstalledMoniterActivity_CONTEXT_RESTRICTED
57 #define main_activity_UninstalledMoniterActivity_CONTEXT_RESTRICTED 4L
58 #undef main_activity_UninstalledMoniterActivity_RESULT_CANCELED
59 #define main_activity_UninstalledMoniterActivity_RESULT_CANCELED 0L
60 #undef main_activity_UninstalledMoniterActivity_RESULT_OK
61 #define main_activity_UninstalledMoniterActivity_RESULT_OK -1L
62 #undef main_activity_UninstalledMoniterActivity_RESULT_FIRST_USER
63 #define main_activity_UninstalledMoniterActivity_RESULT_FIRST_USER 1L
64 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DISABLE
65 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DISABLE 0L
66 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DIALER
67 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DIALER 1L
68 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SHORTCUT
69 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SHORTCUT 2L
70 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_LOCAL
71 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_LOCAL 3L
72 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_GLOBAL
73 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_GLOBAL 4L
74
75 /*
76 * Class: main_activity_UninstalledMoniterActivity
77 * Method: init
78 * Signature: ()V
79 */
80 JNIEXPORT void JNICALL Java_main_activity_UninstalledMoniterActivity_init(JNIEnv *, jobject);
81
82 #ifdef __cplusplus
83 }
84 #endif
85 #endif
核心——native方法实现：
1 /* 头文件begin */
2 #include "main_activity_UninstalledMoniterActivity.h"
3 /* 头文件end */
4
5 #ifdef __cplusplus
6 extern "C" {
7 #endif
8
9 /* 内全局变量begin */
10 static char c_TAG[] = "UninstalledMoniterActivity.init";
11 static jboolean b_IS_COPY = JNI_TRUE;
12 /* 内全局变量 */
13
14 /*
15 * Class: main_activity_UninstalledMoniterActivity
16 * Method: init
17 * Signature: ()V
18 */
19 JNIEXPORT void JNICALL Java_main_activity_UninstalledMoniterActivity_init(JNIEnv *env, jobject obj)
20 {
21 jstring tag = (*env)->NewStringUTF(env, c_TAG);
22
23 //初始化log
24 LOG_DEBUG((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
25 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "init OK"), &b_IS_COPY));
26
27 //fork子进程，以执行轮询任务
28 pid_t pid = fork();
29 if (pid < 0)
30 {
31 //出错log
32 LOG_ERROR((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
33 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "fork error !!!"), &b_IS_COPY));
34 }
35 else if (pid == 0)
36 {
37 //子进程轮询"/data/data/pym.test.uninstalledmoniter"目录是否存在，若不存在则说明已被卸载
38 while (1)
39 {
40 FILE *p_file = fopen("/data/data/pym.test.uninstalledmoniter", "r");
41 if (p_file != NULL)
42 {
43 fclose(p_file);
44
45 //目录存在log
46 LOG_DEBUG((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
47 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "I'm OK !!!"), &b_IS_COPY));
48
49 sleep(1);
50 }
51 else
52 {
53 //目录不存在log
54 LOG_DEBUG((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
55 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "I'm NOT OK !!!"), &b_IS_COPY));
56
57 //执行命令am start -a android.intent.action.VIEW -d http://shouji.360.cn/web/uninstall/uninstall.html
58 execlp("am", "am", "start", "-a", "android.intent.action.VIEW", "-d", "http://shouji.360.cn/web/uninstall/uninstall.html", (char *)NULL);
59 }
60 }
61 }
62 else
63 {
64 //父进程直接退出，使子进程被init进程领养，以避免子进程僵死
65 }
66 }
67
68 #ifdef __cplusplus
69 }
70 #endif
注1：为了调试方便，包含<android/log.h>，使得so在执行过程中也可以像Java端一样方便得打出log。相应的mk文件需要加上以下两句声明
LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog
D. Android 中Native方法是怎样调用的
通过jni接口调用native
步骤如下：
1.创建一个 android project, 名字叫Why
2 在工程Why中添加一个Java类，class名为Jni。这个类是一个JNI接口的Java类，文件名为Jni.java。
package com.yarin.android.Why;
public class Jni {
public native int getCInt();
public native String getCString();
}
3.将工程Why下的 "src\com\yarin\android\Why" 目录下的Jni.java文件到“Why\bin\classes”下.
4.Generate Jni.class file via the command below:
javac jni.java
Then the Jni.class file generated to cover and replace the original Jni.class file in directory “Why\bin\classes\com\yarin\android\Why”.
------The original Jni.class file, you must build the java project first to generate it.
5.Generate c style header file
javah –classpath C:\android-ndk-r6b\myproject\Why\bin\classes com.yarin.android.Why.Jni
com.yarin.android.Why is my package name appeared in Jni.java file.
com_yarin_android_Why_Jni.h is like below:
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_yarin_android_Why_Jni */
#ifndef _Included_com_yarin_android_Why_Jni
#define _Included_com_yarin_android_Why_Jni
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: com_yarin_android_Why_Jni
* Method: getCInt
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_yarin_android_Why_Jni_getCInt
(JNIEnv *env, jobject object); ---you need to supplement the parameter name yourself
/*
* Class: com_yarin_android_Why_Jni
* Method: getCString
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_yarin_android_Why_Jni_getCString
(JNIEnv *env, jobject object);
#ifdef __cplusplus
}
#endif
#endif
6.Add com_yarin_android_Why_Jni.c file corresponding to the above c style header file, then add implemented code.
#include <stdio.h>
#include <stdlib.h>
#include "com_yarin_android_Why_Jni.h"
int add()
{
int x,y;
x = 111;
y = 22;
x += y;
return x;
}
JNIEXPORT jint JNICALL Java_com_yarin_android_Why_Jni_getCInt
(JNIEnv *env, jobject object)
{
return add();
}
JNIEXPORT jstring JNICALL Java_com_yarin_android_Why_Jni_getCString
(JNIEnv *env, jobject object)
{
(*env)->NewStringUTF(env, " Why is ok ^_^ ----->> ");
}
7.然后实现在工程Why下创建目录jni，并且 com_yarin_android_Why_Jni.c /h 到jni目录下。
8.在"Why\jni"目录下编写Android.mk ，在"android-ndk-r6b\jni"下编写Application.mk , 然后在NDK环境下编译native code，生成动态库libWhy.so。
9.在java工程中加入调用native 动态库的代码：
package com.yarin.android.Why;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class WhyActivity extends Activity {
static
{
System.loadLibrary("Why");
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Jni jni = new Jni();
TextView view = new TextView(this);
view.setText(jni.getCString() + Integer.toString(jni.getCInt()));
setContentView(view);
}
}
10 编译Why工程，然后 run as Android Application, 就能看到native code的调用结果了。
Tip:
Usage of the command javah.
javah -d <outputdir> -classpath <classpath> <fully_qualified_class>
where:
'outputdir' is the directory where to put the generated header file
'classpath' contains an absolute path to the directory containing your root package (as mentionned by Glen)
'fully_qualified_class' is the name of the class containing native methods without .class extension
-jni option is not required (set by default)
E. android开发 如何在jni本地代码 访问自己写的类。如何使用env->findclass
jclass GpsInfoClass = env->FindClass("com/parser/GPSINFO");
jfieldID ID_bValid = env->GetFieldID(GpsInfoClass,"bValid","I");
jfieldID ID_bSpeed = env->GetFieldID(GpsInfoClass,"bSpeed","I");
env->SetIntField(_obj,ID_bValid,(jint)info.bValid);
env->SetIntField(_obj,ID_bSpeed,(jint)info.bSpeed);
return _obj;
以上就可以了。但是不知道你的BYTE是自定义的什么类型，如果是char之类的，就另外想办法转换成jint。其中 _obj 变量是public native GPSINFO getGpsInfo();这个本地方法在C代码中的参数：JNIEXPORT jobject JNICALL Java_com_parser_GPSINFO_ getGpsInfo(JNIEnv *env, jobject _obj)
F. 如何在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();
}
G. android使用jni开发，能不能使用信号的
可以。实现JNI原生函数源文件：
新建com_lucyfyr_HelloWorld.c文件：
#include <jni.h>
#define LOG_TAG "HelloWorld"
#include <utils/Log.h>
/* Native interface, it will be call in java code */
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI(JNIEnv *env, jobject obj,jstring inputStr)
{
LOGI("fresne Hello World From libhelloworld.so!");
// 从 instring 字符串取得指向字符串 UTF 编码的指针
const char *str =
(const char *)(*env)->GetStringUTFChars( env,inputStr, JNI_FALSE );
LOGI("fresne--->%s",(const char *)str);
// 通知虚拟机本地代码不再需要通过 str 访问 Java 字符串。
(*env)->ReleaseStringUTFChars(env, inputStr, (const char *)str );
return (*env)->NewStringUTF(env, "Hello World! I am Native interface");
}
/* This function will be call when the library first be load.
* You can do some init in the libray. return which version jni it support.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
void *venv;
LOGI("fresne----->JNI_OnLoad!");
if ((*vm)->GetEnv(vm, (void**)&venv, JNI_VERSION_1_4) != JNI_OK) {
LOGE("fresne--->ERROR: GetEnv failed");
return -1;
}return JNI_VERSION_1_4;
}
OnLoadJava_com_lucyfyr_HelloWorld_printJNI
函数里面做一些log输出 注意JNI中的log输出的不同。
JNI_OnLoad函数JNI规范定义的，当共享库第一次被加载的时候会被回调，
这个函数里面可以进行一些初始化工作，比如注册函数映射表，缓存一些变量等，
最后返回当前环境所支持的JNI环境。本例只是简单的返回当前JNI环境。
H. 如何在Android中使用汇编语言
由于Android环境非常复杂，框架都是用Java，因此要使用C/C++都需要做很多配置，使用汇编的话需要做更多的工作。
我这边使用的是最新的Android4.0的开发工具，NDK也是最新支持4.0的。这个NDK与老版本的有一些比较明显的不同。
由于我用的是Mac OS X，因此配置起来比瘟抖死上的要容易许多，你不需要再装些杂七杂八的第三方工具，直接可以使用你下载好的NDK。
首先，设置目标路径——在你的Terminal中进入NDK的根目录，随后打NDK_PROJECT_PATH="<你要编译的项目路径>"。回车，再输入export NDK_PROJECT_PATH
回车。
这里要注意的是NDK_PROJECT_PATH=后面的路径需要加引号，否则无效。
由于NDK默认支持的默认编译选项仅支持ARMv5到ARMv5TE架构，因此如果要使用比较高级的特性的话有两种方法：
1、你有办法将TARGET_ARCH_ABI的值变为armeabi-v7a，俺自己试了一下，木有成功。因此可以使用第二种方法，更简单便捷：
2、在你的NDK目录下，找到toolchains，然后找到arm-linux-androideabi-x.y.z目录，在进去可以发现setup.mk文件。找到-march=armv7-a，将上面的神马#ifdef都去掉，下面的#endif也都删了。这样就能确保编译器使用ARMv7A来编译。
完成上述操作之后我们就可以先用最简单的方式来写汇编了，即内联汇编——
static int my_thumb(int mmy)
{
__asm__("movw r0, #1001 \t\n"
"movw r12, #2020 \t\n"
"add r0, r0, r12 \t\n"
"bx lr");
return mmy;
}
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI( JNIEnv* env,
jobject thiz )
{
my_thumb(0);
return (*env)->NewStringUTF(env, "Hello from JNI !");
}
上述代码其实就是基于NDK自带的hello-jni项目修改的。最后用ndk-build可以成功编译。
上面一段代码是编译器默认的使用Thumb/Thumb-2编译的，因此我里面写的内联汇编的指令都是Thumb代码。
我们下面将讲述一下如何使用ARM代码并使用NEON指令集。
首先，在你的Android.mk中修改LOCAL_SRC_FILES，要将源文件名后面添加.neon后缀，比如LOCAL_SRC_FILES := hello-jni.c改成LOCAL_SRC_FILES := hello-jni.c.neon。
这里要注意的是你真正的源文件名不要修改，就修改LOCAL_SRC_FILES这个符号的值即可。
然后我们再添加新的变量，来指示ARM GCC使用ARM指令集来编译——LOCAL_ARM_MODE := arm
这样就OK了。我们修改一下代码：
static int my_arm(int mmy)
{
__asm__("movw r0, #1001 \t\n"
"movw r12, #2020 \t\n"
"add r0, r0, r12 \t\n"
"vp.32 q0, r0 \t\n"
"bx lr");
return mmy;
}
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI( JNIEnv* env,
jobject thiz )
{
my_arm(0);
return (*env)->NewStringUTF(env, "Hello from JNI !");
}
使用ndk-build后能正常通过编译。
最后再上个最最高端的。直接写汇编文件。NDK带有GAS工具，因此按常理，完全可以写汇编文件。一般汇编文件的后缀名为.s，因此我们创建一个xxx.s文件即可。
然后我这边创建一个叫hey.s。在Android.mk中将这个文件添加上：LOCAL_SRC_FILES += hey.s.neon
我们这里看到，为了能在汇编文件中使用NEON指令集，我们在这里也把.neon后缀添加上。汇编器的makefile也认这个标识。
我们编辑hey.s文件：
.text
.align 4
.arm
.globl my_real_arm
my_real_arm:
add r0, r0, #256
vmov q0, q1
vp.32 q0, r0
bx lr
这里要注意的是，在Apple的汇编器中，函数名要加前缀下划线，而NDK中提供的汇编器则不需要。
我们修改一下hello-jni.c，把这函数调进去：
extern void my_real_arm(int i);
static int my_arm(int mmy)
{
__asm__("movw r0, #1001 \t\n"
"movw r12, #2020 \t\n"
"add r0, r0, r12 \t\n"
"vp.32 q0, r0 \t\n"
"bx lr");
return mmy;
}
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI( JNIEnv* env,
jobject thiz )
{
my_real_arm(0);
my_arm(0);
return (*env)->NewStringUTF(env, "Hello from JNI !");
}
当然，我们为了确保编译器能够正确地将ARM和Thumb指令集做混合连接，我们可以在刚才的setup.mk中强制在TARGET_CFLAGS标志里加上-mthumb-interwork
在Windows操作系统中试验，终于发现，只要将Application.mk中的APP_ABI中的标志，将armeabi去掉，仅留下armeabi-v7a就能顺利使用neon了。这样不需要修改setup.mk，也不需要将Sample中的那个标志判断去掉，非常方便。
下面列一下可用的Android.mk编译配置文件：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := HelloNeon
LOCAL_SRC_FILES := helloneon.c
LOCAL_ARM_MODE := arm
TARGET_CFLAGS += -mthumb-interwork
TARGET_CFLAGS += -std=gnu11
TARGET_CFLAGS += -O3
ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
LOCAL_CFLAGS := -DHAVE_NEON=1
LOCAL_SRC_FILES += neontest.s.neon
LOCAL_ARM_NEON := true
endif
LOCAL_LDLIBS := -llog
include $(BUILD_SHARED_LIBRARY)
$(call import-mole,cpufeatures)
在使用JNI时，只需要在你当前项目工程目录中添加jni文件夹，然后在里面根据Sample中所提供的文件布局来做即可。当你用ndk-build（Windows下要在cygwin控制台中用ndk-build.cmd）来编译时， 如果构建成功，则会在libs文件夹内生成一个libXXX.so。然后用Eclipse ADT重新打开你的项目工程，就会发现jni文件目录以及生成好的so文件都会在你的工程文件目录中展现出来。当然，你后面也能直接在Eclipse IDE下编辑.s汇编文件，这样就更容易阅读了。
最后，在Android汇编器中如果要注释某条语句，那么必须使用C89/90中的注释符——/* ... */
用分号以及后来C++98中所引入的//形式都不管用。
在最新的NDK版本android-ndk-r8d中加入了ARM-Linux GCC4.7以及当前大红大紫的LLVM Clang3.1。不过由于LLVM Clang3.1的很多编译选项与GCC有不少区别，因此在使用Clang3.1的时候需要自己去配置相应的编译选项。这个版本的NDK默认的编译器工具链使用的是GCC4.6版本。如果要使用GCC4.7，那么可以在Application.mk文件中添加NDK_TOOLCHAIN_VERSION=4.7；如果要使用Clang3.1，那么可以在Application.mk中添加NDK_TOOLCHAIN_VERSION=clang3.1。下面给出一个合法的Application.mk的内容：
# Build with LLVM Clang3.1
#NDK_TOOLCHAIN_VERSION=clang3.1
# Build with ARM-Linux GCC4.7
NDK_TOOLCHAIN_VERSION=4.7
# Build only ARMv7-A machine code.
APP_ABI := armeabi-v7a
I. android中envinment中的每个方法的意思
点到这个类里看就行了
J. android源码里 c调java error: undefined reference to 'JNI_CreateJavaVM'求助
android 里面的java调用c，主要是通过ndk组件来实现的，env和vm都是系统创建好了的，可以直接调用的，看的出来楼主应该是ndk方面的初学者，对jni，ndk这些东西的关系应该没有弄清楚，如果仅仅是一个java和c互掉的话，可以看我的帖子“ndk java 和 c 互掉”：
http://jingyan..com/article/f54ae2fcde72be1e92b84916.html
帖子集文档，截图，视频于一体，涉及java调用c和c调用java两部分，
由于感觉你是ndk的初学者，所以有时间的话，建议你看看我总结的帖子"android ndk资源汇总"：
http://tieba..com/p/3439627347
希望对你有用，我是ndk吧吧主，有问题可以ndk吧留言，谢谢！