Refactoring the android api for resorce-encapsulation.
[platform/upstream/iotivity.git] / service / resource-encapsulation / android / service / src / main / jni / util / JNIEnvWrapper.h
1 /******************************************************************
2  *
3  * Copyright 2015 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  ******************************************************************/
20
21 #ifndef RCS_JNI_ENV_WRAPPER_H_
22 #define RCS_JNI_ENV_WRAPPER_H_
23
24 #include <jni.h>
25
26 #include <exception>
27
28 #include "JavaLocalRef.h"
29
30 class JavaException: public std::exception
31 {
32 };
33
34 class JNIEnvWrapper
35 {
36 public:
37     JNIEnvWrapper() noexcept : m_env{ } {}
38     JNIEnvWrapper(JNIEnv* env) noexcept : m_env{ env } {}
39
40     JNIEnvWrapper& operator=(JNIEnv* env) noexcept
41     {
42         m_env = env;
43         return *this;
44     }
45
46     jboolean IsSameObject(jobject lhs, jobject rhs)
47     {
48         return m_env->IsSameObject(lhs, rhs);
49     }
50
51     jclass GetObjectClass(jobject obj)
52     {
53         auto ret = m_env->GetObjectClass(obj);
54         if (m_env->ExceptionCheck()) throw JavaException();
55         return ret;
56     }
57
58     jclass FindClass(const char* name)
59     {
60         auto ret = m_env->FindClass(name);
61         if (m_env->ExceptionCheck()) throw JavaException();
62         return ret;
63     }
64
65     jclass FindClassAsGlobalRef(const char* name)
66     {
67         JavaLocalClass cls{ m_env, FindClass(name) };
68
69         return NewGlobalRef(cls);
70     }
71
72     jobject NewGlobalRef(jobject obj)
73     {
74         auto ret = m_env->NewGlobalRef(obj);
75         if (m_env->ExceptionCheck()) throw JavaException();
76         return ret;
77     }
78
79     template<typename T>
80     T NewGlobalRef(T obj)
81     {
82         auto ret = static_cast< T >(m_env->NewGlobalRef(obj));
83         if (m_env->ExceptionCheck()) throw JavaException();
84         return ret;
85     }
86
87     template<typename T>
88     T NewGlobalRef(const JavaLocalRef< T >& obj)
89     {
90         auto ret = static_cast< T >(m_env->NewGlobalRef(obj));
91         if (m_env->ExceptionCheck()) throw JavaException();
92         return ret;
93     }
94
95     void DeleteGlobalRef(jobject obj)
96     {
97         m_env->DeleteGlobalRef(obj);
98     }
99
100     jobject NewObject(jclass cls, jmethodID ctor, ...)
101     {
102         va_list args;
103         va_start(args, ctor);
104         auto ret = m_env->NewObjectV(cls, ctor,args);
105         va_end(args);
106
107         if (m_env->ExceptionCheck()) throw JavaException();
108         return ret;
109     }
110
111     jstring NewStringUTF(const char* str)
112     {
113         auto ret = m_env->NewStringUTF(str);
114         if (m_env->ExceptionCheck()) throw JavaException();
115         return ret;
116     }
117
118     const char* GetStringUTFChars(jstring str, jboolean* isCopy)
119     {
120         auto ret = m_env->GetStringUTFChars(str, isCopy);
121         if (m_env->ExceptionCheck()) throw JavaException();
122         return ret;
123     }
124
125     void ReleaseStringUTFChars(jstring str, const char* chars)
126     {
127         m_env->ReleaseStringUTFChars(str, chars);
128         if (m_env->ExceptionCheck()) throw JavaException();
129     }
130
131     jmethodID GetConstructorID(jclass cls, const char* sig)
132     {
133         auto ret = m_env->GetMethodID(cls, "<init>", sig);
134         if (m_env->ExceptionCheck()) throw JavaException();
135         return ret;
136     }
137
138     jmethodID GetMethodID(jclass cls, const char* name, const char* sig)
139     {
140         auto ret = m_env->GetMethodID(cls, name, sig);
141         if (m_env->ExceptionCheck()) throw JavaException();
142         return ret;
143     }
144
145     jmethodID GetStaticMethodID(jclass cls, const char* name, const char* sig)
146     {
147         auto ret = m_env->GetStaticMethodID(cls, name, sig);
148         if (m_env->ExceptionCheck()) throw JavaException();
149         return ret;
150     }
151
152
153     jfieldID GetFieldID(jclass cls, const char* name, const char* sig)
154     {
155         auto ret = m_env->GetFieldID(cls, name, sig);
156         if (m_env->ExceptionCheck()) throw JavaException();
157         return ret;
158     }
159
160     jfieldID GetStaticFieldID(jclass cls, const char* name, const char* sig)
161     {
162         auto ret = m_env->GetStaticFieldID(cls, name, sig);
163         if (m_env->ExceptionCheck()) throw JavaException();
164         return ret;
165     }
166
167     jobject GetStaticObjectField(jclass cls, jfieldID fieldId)
168     {
169         auto ret = m_env->GetStaticObjectField(cls, fieldId);
170         if (m_env->ExceptionCheck()) throw JavaException();
171         return ret;
172     }
173
174     jobject GetStaticObjectField(jclass cls, const char* name, const char* sig)
175     {
176         return GetStaticObjectField(cls, GetStaticFieldID(cls, name, sig));
177     }
178
179     jint GetIntField(jobject obj, jfieldID fieldId)
180     {
181         auto ret = m_env->GetIntField(obj, fieldId);
182         if (m_env->ExceptionCheck()) throw JavaException();
183         return ret;
184     }
185
186     jlong GetLongField(jobject obj, jfieldID fieldId)
187     {
188         auto ret = m_env->GetLongField(obj, fieldId);
189         if (m_env->ExceptionCheck()) throw JavaException();
190         return ret;
191     }
192
193     void SetLongField(jobject obj, jfieldID fieldId, jlong val)
194     {
195         m_env->SetLongField(obj, fieldId, val);
196         if (m_env->ExceptionCheck()) throw JavaException();
197     }
198
199     jobject GetObjectField(jobject obj, jfieldID fieldId)
200     {
201         auto ret = m_env->GetObjectField(obj, fieldId);
202         if (m_env->ExceptionCheck()) throw JavaException();
203         return ret;
204     }
205
206     jint CallStaticIntMethod(jclass cls, jmethodID methodId, ...)
207     {
208         va_list args;
209         va_start(args, methodId);
210         auto ret = m_env->CallStaticIntMethodV(cls, methodId, args);
211         va_end(args);
212         if (m_env->ExceptionCheck()) throw JavaException();
213         return ret;
214     }
215
216     jobject CallStaticObjectMethod(jclass cls, jmethodID methodId, ...)
217     {
218         va_list args;
219         va_start(args, methodId);
220         auto ret = m_env->CallStaticObjectMethodV(cls, methodId, args);
221         va_end(args);
222         if (m_env->ExceptionCheck()) throw JavaException();
223         return ret;
224     }
225
226     void CallVoidMethod(jobject obj, jmethodID methodId, ...)
227     {
228          va_list args;
229          va_start(args, methodId);
230          m_env->CallVoidMethodV(obj, methodId, args);
231          va_end(args);
232          if (m_env->ExceptionCheck()) throw JavaException();
233     }
234
235     jboolean CallBooleanMethod(jobject obj, jmethodID methodId, ...)
236     {
237         va_list args;
238         va_start(args, methodId);
239         auto ret = m_env->CallBooleanMethodV(obj, methodId, args);
240         va_end(args);
241         if (m_env->ExceptionCheck()) throw JavaException();
242         return ret;
243     }
244
245     jint CallIntMethod(jobject obj, jmethodID methodId, ...)
246     {
247          va_list args;
248          va_start(args, methodId);
249          auto ret = m_env->CallIntMethod(obj, methodId, args);
250          va_end(args);
251          if (m_env->ExceptionCheck()) throw JavaException();
252          return ret;
253     }
254
255      jdouble CallDoubleMethod(jobject obj, jmethodID methodId, ...)
256      {
257           va_list args;
258           va_start(args ,methodId);
259           auto ret = m_env->CallDoubleMethod(obj, methodId, args);
260           va_end(args);
261           if (m_env->ExceptionCheck()) throw JavaException();
262           return ret;
263      }
264
265
266     jobject CallObjectMethod(jobject obj, jmethodID methodId, ...)
267     {
268         va_list args;
269         va_start(args, methodId);
270         auto ret = m_env->CallObjectMethodV(obj, methodId, args);
271         va_end(args);
272         if (m_env->ExceptionCheck()) throw JavaException();
273         return ret;
274     }
275
276     jbooleanArray NewBooleanArray(jsize len)
277     {
278         auto ret = m_env->NewBooleanArray(len);
279         if (m_env->ExceptionCheck()) throw JavaException();
280         return ret;
281     }
282
283     jintArray NewIntArray(jsize len)
284     {
285         auto ret = m_env->NewIntArray(len);
286         if (m_env->ExceptionCheck()) throw JavaException();
287         return ret;
288     }
289
290     jdoubleArray NewDoubleArray(jsize len)
291     {
292         auto ret = m_env->NewDoubleArray(len);
293         if (m_env->ExceptionCheck()) throw JavaException();
294         return ret;
295     }
296
297     jobjectArray NewObjectArray(jsize len, jclass cls, jobject init)
298     {
299         auto ret = m_env->NewObjectArray(len, cls, init);
300         if (m_env->ExceptionCheck()) throw JavaException();
301         return ret;
302     }
303
304     jsize GetArrayLength(jarray array)
305     {
306         auto ret = m_env->GetArrayLength(array);
307         if (m_env->ExceptionCheck()) throw JavaException();
308         return ret;
309     }
310
311     jobject GetObjectArrayElement(jobjectArray array, jsize index)
312     {
313         auto ret = m_env->GetObjectArrayElement(array, index);
314         if (m_env->ExceptionCheck()) throw JavaException();
315         return ret;
316     }
317
318     void SetObjectArrayElement(jobjectArray array, jsize index, jobject val)
319     {
320         m_env->SetObjectArrayElement(array, index, val);
321         if (m_env->ExceptionCheck()) throw JavaException();
322     }
323
324     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, const jboolean* buf)
325     {
326         m_env->SetBooleanArrayRegion(array, start, len, buf);
327         if (m_env->ExceptionCheck()) throw JavaException();
328     }
329
330     void SetIntArrayRegion(jintArray array, jsize start, jsize len, const jint* buf)
331     {
332         m_env->SetIntArrayRegion(array, start, len, buf);
333         if (m_env->ExceptionCheck()) throw JavaException();
334     }
335
336     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, const jdouble* buf)
337     {
338         m_env->SetDoubleArrayRegion(array, start, len, buf);
339         if (m_env->ExceptionCheck()) throw JavaException();
340     }
341
342     void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy)
343     {
344         auto ret = m_env->GetPrimitiveArrayCritical(array, isCopy);
345         if (m_env->ExceptionCheck()) throw JavaException();
346         return ret;
347     }
348
349     void ReleasePrimitiveArrayCritical(jarray array, void* carray, int mode)
350     {
351         m_env->ReleasePrimitiveArrayCritical(array, carray, mode);
352         if (m_env->ExceptionCheck()) throw JavaException();
353     }
354
355     void ThrowNew(jclass cls, const char* msg) {
356         m_env->ThrowNew(cls, msg);
357         throw JavaException();
358     }
359
360     void ExceptionDescribe() const noexcept
361     {
362         m_env->ExceptionDescribe();
363     }
364
365     void ExceptionClear() noexcept
366     {
367         m_env->ExceptionClear();
368     }
369
370     jboolean ExceptionCheck() const noexcept
371     {
372         return m_env->ExceptionCheck();
373     }
374
375     operator bool() const noexcept
376     {
377         return m_env != nullptr;
378     }
379
380     JNIEnv* get() const
381     {
382         return m_env;
383     }
384
385 private:
386     JNIEnv* m_env;
387 };
388
389
390
391 #endif // RCS_JNI_ENV_WRAPPER_H_