service/simulator/java/jni/simulator_resource_jni_util.cpp

   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 #include "simulator_resource_jni_util.h"
  21 #include "simulator_common_jni.h"
  22
  23 extern SimulatorClassRefs gSimulatorClassRefs;
  24
  25 std::vector<int> convertIntegerVector(JNIEnv *env, jobject jVectorInt)
  26 {
  27     std::vector<int> vectorInt;
  28
  29     jclass vectorClass = env->FindClass("java/util/Vector");
  30     if (!vectorClass)
  31     {
  32         return vectorInt;
  33     }
  34
  35     jmethodID size = env->GetMethodID(vectorClass, "size", "()I");
  36     if (NULL == size)
  37     {
  38         return vectorInt;
  39     }
  40
  41     jmethodID get = env->GetMethodID(vectorClass, "get", "(I)""Ljava/lang/Object;");
  42     if (NULL == get)
  43     {
  44         return vectorInt;
  45     }
  46
  47     jint jSize = env->CallIntMethod(jVectorInt, size);
  48     int sizeOfVector = jSize;
  49
  50     for (int index = 0; index < sizeOfVector; index++)
  51     {
  52         jint jIndex = index;
  53         jint jValue = env->CallIntMethod(jVectorInt, get, jIndex);
  54         vectorInt.push_back((int)jValue);
  55     }
  56
  57     return vectorInt;
  58 }
  59
  60 std::vector<double> convertDoubleVector(JNIEnv *env, jobject jVectorDouble)
  61 {
  62     std::vector<double> vectorDouble;
  63
  64     jclass vectorClass = env->FindClass("java/util/Vector");
  65     if (!vectorClass)
  66     {
  67         return vectorDouble;
  68     }
  69
  70     jmethodID size = env->GetMethodID(vectorClass, "size", "()I");
  71     if (NULL == size)
  72     {
  73         return vectorDouble;
  74     }
  75
  76     jmethodID get = env->GetMethodID(vectorClass, "get", "(I)""Ljava/lang/Object;");
  77     if (NULL == get)
  78     {
  79         return vectorDouble;
  80     }
  81
  82     jint jSize = env->CallIntMethod(jVectorDouble, size);
  83     int sizeOfVector = jSize;
  84
  85     for (int index = 0; index < sizeOfVector; index++)
  86     {
  87         jint jIndex = index;
  88         jdouble jValue = env->CallDoubleMethod(jVectorDouble, get, jIndex);
  89         vectorDouble.push_back((double)jValue);
  90     }
  91
  92     return vectorDouble;
  93 }
  94
  95 std::vector<std::string> convertStringVector(JNIEnv *env, jobject jVectorString)
  96 {
  97     std::vector<std::string> vectorString;
  98
  99     jclass vectorClass = env->FindClass("java/util/Vector");
 100     if (!vectorClass)
 101     {
 102         return vectorString;
 103     }
 104
 105     jmethodID size = env->GetMethodID(vectorClass, "size", "()I");
 106     if (NULL == size)
 107     {
 108         return vectorString;
 109     }
 110
 111     jmethodID get = env->GetMethodID(vectorClass, "get", "(I)""Ljava/lang/Object;");
 112     if (NULL == get)
 113     {
 114         return vectorString;
 115     }
 116
 117     jint jSize = env->CallIntMethod(jVectorString, size);
 118     int sizeOfVector = jSize;
 119
 120     for (int index = 0; index < sizeOfVector; index++)
 121     {
 122         jint jIndex = index;
 123         jstring jContactInfoObj = (jstring)env->CallObjectMethod(jVectorString, get, jIndex);
 124         if (jContactInfoObj == NULL)
 125         {
 126             return vectorString;
 127         }
 128         const char *buff = env->GetStringUTFChars(jContactInfoObj, 0);
 129         if (NULL != buff)
 130         {
 131             std::string tempString = buff;
 132             vectorString.push_back(tempString);
 133         }
 134
 135         env->ReleaseStringUTFChars(jContactInfoObj, buff);
 136     }
 137
 138     return vectorString;
 139 }
 140
 141 void convertJavaMapToQueryParamsMap(JNIEnv *env, jobject hashMap,
 142                                     std::map<std::string, std::string> &queryParams)
 143 {
 144     if (!hashMap) return;
 145
 146     jobject jEntrySet = env->CallObjectMethod(hashMap, gSimulatorClassRefs.classMapEntrySet);
 147     jobject jIterator = env->CallObjectMethod(jEntrySet, gSimulatorClassRefs.classIteratorId);
 148     if (!jEntrySet || !jIterator || env->ExceptionCheck()) return;
 149
 150     while (env->CallBooleanMethod(jIterator, gSimulatorClassRefs.classHasNextId))
 151     {
 152         jobject jEntry = env->CallObjectMethod(jIterator, gSimulatorClassRefs.classNextId);
 153         if (!jEntry) return;
 154         jstring jKey = (jstring)env->CallObjectMethod(jEntry, gSimulatorClassRefs.classMapGetKey);
 155         if (!jKey) return;
 156         jstring jValue = (jstring)env->CallObjectMethod(jEntry, gSimulatorClassRefs.classMapGetValue);
 157         if (!jValue) return;
 158
 159         queryParams.insert(std::make_pair(env->GetStringUTFChars(jKey, NULL),
 160                                           env->GetStringUTFChars(jValue, NULL)));
 161
 162         if (env->ExceptionCheck()) return;
 163         env->DeleteLocalRef(jEntry);
 164         env->DeleteLocalRef(jKey);
 165         env->DeleteLocalRef(jValue);
 166     }
 167 }
 168
 169 jobject convertHashMapToJavaMap(JNIEnv *env,
 170                                 const std::map<std::string, uint8_t> &observersList)
 171 {
 172     if (observersList.empty())
 173     {
 174         return NULL;
 175     }
 176
 177     jobject jObserverListMap = env->NewObject(gSimulatorClassRefs.classHashMap,
 178                                gSimulatorClassRefs.classHashMapCtor);
 179
 180     for (auto it = observersList.begin(); it != observersList.end(); ++it)
 181     {
 182         jstring key = (*env).NewStringUTF( (*it).first.c_str() );
 183         jint value = (*it).second;
 184         env->CallObjectMethod(jObserverListMap, gSimulatorClassRefs.classHashMapPut, key, value);
 185     }
 186
 187     return jObserverListMap;
 188 }
 189
 190 jobject convertStringVectorToJavaList(JNIEnv *env, std::vector<std::string> &vector)
 191 {
 192     jobject jList = env->NewObject(gSimulatorClassRefs.classLinkedList,
 193                                    gSimulatorClassRefs.classLinkedListCtor);
 194     if (!jList) return nullptr;
 195     for (size_t i = 0; i < vector.size(); ++i)
 196     {
 197         jstring jStr = env->NewStringUTF(vector[i].c_str());
 198         if (!jStr) return nullptr;
 199         env->CallBooleanMethod(jList, gSimulatorClassRefs.classLinkedListAddObject, jStr);
 200         if (env->ExceptionCheck()) return nullptr;
 201         env->DeleteLocalRef(jStr);
 202     }
 203     return jList;
 204 }
 205
 206