android NDK 实用学习（五）-c++端调用java接口

时间：2015-07-01 13:50:01 阅读：833 评论：0 收藏：0 [点我收藏+]

标签：

1，阅读此文章前请阅读前面文章，以免阅读出现障碍；

android NDK 实用学习（一）-获取java端类及其类变量

android NDK 实用学习（二）-java端对象成员赋值和获取对象成员值

android NDK 实用学习（三）- java端类对象的构造及使用

android NDK 实用学习（四）-类缓存

2，java端类接口定义：

 1  public class RTKNativeManager {
 2       // 其他接口
 3      
 4      // 开给c++端的接口
 5      public static void notifyResolveResult(short id, TestSetData setData) {
 6          Log.d(TAG, "notifyResult start");
 7 
 8          boolean bb = setData.bData;
 9          int ii = setData.iData;
10          String msg = String.format("get msg: %b-%d", bb, ii);
11          Log.d(TAG, msg);
12  
13          Log.d(TAG, "notifyResult end!");
14      }
15 }

3, c++ 端获取类接口:

1     // 获取类
2     jclass jnativeMgr = NULL;
3     jmethodID jnotifyKQResolveResult = NULL;
4 
5     // 获取类和方法
6     jnativeMgr = env->FindClass("com/dasea/test/core/RTKNativeManager");
7 
8     jnotifyKQResolveResult = env->GetStaticMethodID(
9             jnativeMgr, "notifyKQResolveResult", "(SLcom/dasea/test/core/TestSetData;)V");

3, 使用：

 1 void Jni_Call_Java_notifyResolveResult(short id){
 2     DEBUG_OUT(" WHAT QINGKUANG!!");
 3 
 4     JNIEnv* env = JniHelper::getEnv();
 5     if (NULL == env)
 6     {
 7         DEBUG_OUT(" ENV IS NULL!");
 8         return ;
 9     }
10 
11     // 获取类和方法
12     jclass jnativeMgr = env->FindClass("com/dasea/test/core/RTKNativeManager");
13     if (NULL == jnativeMgr)
14     {
15         DEBUG_OUT("Native mgr is NULL;!");
16     }
17 
18     // 构造jni实例
19    jclass jcSetDataMgr = env->FindClass("com/dasea/test/core/TestSetData");
20     if(NULL == jcSetDataMgr){
21         DEBUG_OUT("Not find class!");
22         return ;
23     }
24 
25     DEBUG_OUT("AllocObject object !");
26     jmethodID initID = env->GetMethodID(jcSetDataMgr, "<init>", "()V");
27     jobject jresult = env->NewObject(jcSetDataMgr, initID);
28 
29     if (NULL == jresult || env->ExceptionOccurred())
30     {
31         DEBUG_OUT("Construct object failed!");
32         return ;
33     }
34 
35     // 成员变量赋值，可以参考前面几篇文章
36 
37     DEBUG_OUT("CallStaticVoidMethod");
38 
39     // 调用静态方法
40     env->CallStaticVoidMethod(jnativeMgr, jnotifyKQResolveResult , 20, jresult);
41 }

4，上面代码中有Jnihelper类，代码如下：

 1 #ifndef __ANDROID_JNI_HELPER_H__
 2 #define __ANDROID_JNI_HELPER_H__
 3 
 4 #include <jni.h>
 5 #include <string>
 6 
 7 typedef struct JniMethodInfo_ {
 8     JNIEnv * env;
 9     jclass classID;
10     jmethodID methodID;
11 } JniMethodInfo;
12 
13 class JniHelper {
14 public:
15     static void setJavaVM(JavaVM *javaVM);
16     static JavaVM* getJavaVM();
17     static JNIEnv* getEnv();
18 
19     static bool setClassLoaderFrom(jobject activityInstance);
20     static bool getStaticMethodInfo(JniMethodInfo &methodinfo,
21             const char *className, const char *methodName,
22             const char *paramCode);
23     static bool getMethodInfo(JniMethodInfo &methodinfo, const char *className,
24             const char *methodName, const char *paramCode);
25 
26     static std::string jstring2string(jstring str);
27 
28     static jmethodID loadclassMethod_methodID;
29     static jobject classloader;
30 
31 private:
32     static JNIEnv* cacheEnv(JavaVM* jvm);
33 
34     static bool getMethodInfo_DefaultClassLoader(JniMethodInfo &methodinfo,
35             const char *className, const char *methodName,
36             const char *paramCode);
37 
38     static JavaVM* _psJavaVM;
39 };
40 
41 #endif // __ANDROID_JNI_HELPER_H__

  1 /****************************************************************************
  2  Copyright (c) 2010-2012 cocos2d-x.org
  3  Copyright (c) 2013-2014 Chukong Technologies Inc.
  4 
  5  http://www.cocos2d-x.org
  6 
  7  Permission is hereby granted, free of charge, to any person obtaining a copy
  8  of this software and associated documentation files (the "Software"), to deal
  9  in the Software without restriction, including without limitation the rights
 10  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 11  copies of the Software, and to permit persons to whom the Software is
 12  furnished to do so, subject to the following conditions:
 13 
 14  The above copyright notice and this permission notice shall be included in
 15  all copies or substantial portions of the Software.
 16 
 17  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 18  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 22  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 23  THE SOFTWARE.
 24  ****************************************************************************/
 25 #include "JniHelper.h"
 26 #include <string.h>
 27 #include <pthread.h>
 28 #include "CBasePara.h"
 29 
 30 static pthread_key_t g_key;
 31 
 32 jclass _getClassID(const char *className) {
 33     if (NULL == className) {
 34         return NULL;
 35     }
 36 
 37     JNIEnv* env = JniHelper::getEnv();
 38 
 39     jstring _jstrClassName = env->NewStringUTF(className);
 40 
 41 //    jclass _clazz = (jclass) env->CallObjectMethod(JniHelper::classloader,
 42 //                                                   JniHelper::loadclassMethod_methodID,
 43 //                                                   _jstrClassName);
 44 
 45     jclass _clazz = (jclass) env->FindClass(className);
 46 
 47     if (NULL == _clazz) {
 48         DEBUG_OUT("Classloader failed to find class of %s", className);
 49         env->ExceptionClear();
 50     }
 51 
 52     env->DeleteLocalRef(_jstrClassName);
 53 
 54     return _clazz;
 55 }
 56 
 57 JavaVM* JniHelper::_psJavaVM = NULL;
 58 jmethodID JniHelper::loadclassMethod_methodID = NULL;
 59 jobject JniHelper::classloader = NULL;
 60 
 61 JavaVM* JniHelper::getJavaVM() {
 62     pthread_t thisthread = pthread_self();
 63     //LOGD("JniHelper::getJavaVM(), pthread_self() = %ld", thisthread);
 64     return _psJavaVM;
 65 }
 66 
 67 void JniHelper::setJavaVM(JavaVM *javaVM) {
 68     pthread_t thisthread = pthread_self();
 69     //LOGD("JniHelper::setJavaVM(%p), pthread_self() = %ld", javaVM, thisthread);
 70     _psJavaVM = javaVM;
 71 
 72     pthread_key_create(&g_key, NULL);
 73 }
 74 
 75 JNIEnv* JniHelper::cacheEnv(JavaVM* jvm) {
 76     JNIEnv* _env = NULL;
 77     // get jni environment
 78     jint ret = jvm->GetEnv((void**) &_env, JNI_VERSION_1_4);
 79 
 80     switch (ret) {
 81     case JNI_OK:
 82         // Success!
 83         pthread_setspecific(g_key, _env);
 84         return _env;
 85 
 86     case JNI_EDETACHED:
 87         // Thread not attached
 88 
 89         // TODO : If calling AttachCurrentThread() on a native thread
 90         // must call DetachCurrentThread() in future.
 91         // see: http://developer.android.com/guide/practices/design/jni.html
 92 
 93         if (jvm->AttachCurrentThread(&_env, NULL) < 0) {
 94             DEBUG_OUT(
 95                     "Failed to get the environment using AttachCurrentThread()");
 96 
 97             return NULL;
 98         } else {
 99             // Success : Attached and obtained JNIEnv!
100             pthread_setspecific(g_key, _env);
101             return _env;
102         }
103 
104     case JNI_EVERSION:
105         // Cannot recover from this error
106         DEBUG_OUT("JNI interface version 1.4 not supported");
107     default:
108         DEBUG_OUT("Failed to get the environment using GetEnv()");
109         return NULL;
110     }
111 }
112 
113 JNIEnv* JniHelper::getEnv() {
114     JNIEnv *_env = (JNIEnv *) pthread_getspecific(g_key);
115     if (_env == NULL)
116         _env = JniHelper::cacheEnv(_psJavaVM);
117     return _env;
118 }
119 
120 bool JniHelper::setClassLoaderFrom(jobject activityinstance) {
121     JniMethodInfo _getclassloaderMethod;
122     if (!JniHelper::getMethodInfo_DefaultClassLoader(_getclassloaderMethod,
123             "android/content/Context", "getClassLoader",
124             "()Ljava/lang/ClassLoader;")) {
125         return false;
126     }
127 
128     jobject _c = JniHelper::getEnv()->CallObjectMethod(activityinstance,
129             _getclassloaderMethod.methodID);
130 
131     if (NULL == _c) {
132         return false;
133     }
134 
135     JniMethodInfo _m;
136     if (!JniHelper::getMethodInfo_DefaultClassLoader(_m,
137             "java/lang/ClassLoader", "loadClass",
138             "(Ljava/lang/String;)Ljava/lang/Class;")) {
139         return false;
140     }
141 
142     JniHelper::classloader = JniHelper::getEnv()->NewGlobalRef(_c);
143     JniHelper::loadclassMethod_methodID = _m.methodID;
144 
145     return true;
146 }
147 
148 bool JniHelper::getStaticMethodInfo(JniMethodInfo &methodinfo,
149         const char *className, const char *methodName, const char *paramCode) {
150     if ((NULL == className) || (NULL == methodName) || (NULL == paramCode)) {
151         return false;
152     }
153 
154     JNIEnv *env = JniHelper::getEnv();
155     if (!env) {
156         DEBUG_OUT("Failed to get JNIEnv");
157         return false;
158     }
159 
160     jclass classID = _getClassID(className);
161     if (!classID) {
162         DEBUG_OUT("Failed to find class %s", className);
163         env->ExceptionClear();
164         return false;
165     }
166 
167     jmethodID methodID = env->GetStaticMethodID(classID, methodName, paramCode);
168     if (!methodID) {
169         DEBUG_OUT("Failed to find static method id of %s", methodName);
170         env->ExceptionClear();
171         return false;
172     }
173 
174     methodinfo.classID = classID;
175     methodinfo.env = env;
176     methodinfo.methodID = methodID;
177     return true;
178 }
179 
180 bool JniHelper::getMethodInfo_DefaultClassLoader(JniMethodInfo &methodinfo,
181         const char *className, const char *methodName, const char *paramCode) {
182     if ((NULL == className) || (NULL == methodName) || (NULL == paramCode)) {
183         return false;
184     }
185 
186     JNIEnv *env = JniHelper::getEnv();
187     if (!env) {
188         return false;
189     }
190 
191     jclass classID = env->FindClass(className);
192     if (!classID) {
193         DEBUG_OUT("Failed to find class %s", className);
194         env->ExceptionClear();
195         return false;
196     }
197 
198     jmethodID methodID = env->GetMethodID(classID, methodName, paramCode);
199     if (!methodID) {
200         DEBUG_OUT("Failed to find method id of %s", methodName);
201         env->ExceptionClear();
202         return false;
203     }
204 
205     methodinfo.classID = classID;
206     methodinfo.env = env;
207     methodinfo.methodID = methodID;
208 
209     return true;
210 }
211 
212 bool JniHelper::getMethodInfo(JniMethodInfo &methodinfo, const char *className,
213         const char *methodName, const char *paramCode) {
214     if ((NULL == className) || (NULL == methodName) || (NULL == paramCode)) {
215         return false;
216     }
217 
218     JNIEnv *env = JniHelper::getEnv();
219     if (!env) {
220         return false;
221     }
222 
223     jclass classID = _getClassID(className);
224     if (!classID) {
225         DEBUG_OUT("Failed to find class %s", className);
226         env->ExceptionClear();
227         return false;
228     }
229 
230     jmethodID methodID = env->GetMethodID(classID, methodName, paramCode);
231     if (!methodID) {
232         DEBUG_OUT("Failed to find method id of %s", methodName);
233         env->ExceptionClear();
234         return false;
235     }
236 
237     methodinfo.classID = classID;
238     methodinfo.env = env;
239     methodinfo.methodID = methodID;
240 
241     return true;
242 }
243 
244 std::string JniHelper::jstring2string(jstring jstr) {
245     if (jstr == NULL) {
246         return "";
247     }
248 
249     JNIEnv *env = JniHelper::getEnv();
250     if (!env) {
251         return NULL;
252     }
253 
254     const char* chars = env->GetStringUTFChars(jstr, NULL);
255     std::string ret(chars);
256     env->ReleaseStringUTFChars(jstr, chars);
257 
258     return ret;
259 }

View Code

5，在c++端定义JNI_OnLoad接口：

1 jint JNI_OnLoad(JavaVM *vm, void *reserved) {
2     JniHelper::setJavaVM(vm);
3 
4     return JNI_VERSION_1_4;
5 }

6，注意：

如果使用c++端调用java端接口时，就需要通过JniHelper::getEnv()接口获取env。

android NDK 实用学习（五）-c++端调用java接口

标签：

原文地址：http://www.cnblogs.com/dhf-0214/p/4612946.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行