service/resource-container/android/resource-container/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         {
 357             m_env->ThrowNew(cls, msg);
 358             throw JavaException();
 359         }
 360
 361         void ExceptionDescribe() const noexcept
 362         {
 363             m_env->ExceptionDescribe();
 364         }
 365
 366         void ExceptionClear() noexcept
 367         {
 368             m_env->ExceptionClear();
 369         }
 370
 371         jboolean ExceptionCheck() const noexcept
 372         {
 373             return m_env->ExceptionCheck();
 374         }
 375
 376         operator bool() const noexcept
 377         {
 378             return m_env != nullptr;
 379         }
 380
 381         JNIEnv *get() const
 382         {
 383             return m_env;
 384         }
 385
 386     private:
 387         JNIEnv *m_env;
 388 };
 389
 390
 391
 392 #endif // RCS_JNI_ENV_WRAPPER_H_