162 

   163 //----------------------------------------------------------------------------

   164 

   165 JavaStaticMethod::JavaStaticMethod(JNIEnv *Env, jclass Class, jmethodID Method) {

   166     FEnv = Env;

   167     FClass = Class;

   168     FMethod = Method;

   169 }

   170 

   171 void JavaStaticMethod::CallVoidMethod(int Count, ...) {

   172     va_list args;

   173     va_start(args, Count);

   174     FEnv->CallStaticVoidMethodV(FClass, FMethod, args);

   175     va_end(args);

   176 

   177     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   178         Messages& messages = Messages::GetInstance();

   179         throw JavaException(FEnv, messages.GetMessage(ERROR_INVOKING_METHOD));

   180     }

   181 }

   182 

   183 JavaStaticMethod::operator jmethodID () {

   184     return FMethod;

   185 }

   186 

   187 //----------------------------------------------------------------------------

   188 

   189 JavaMethod::JavaMethod(JNIEnv *Env, jobject Obj, jmethodID Method) {

   190     FEnv = Env;

   191     FObj = Obj;

   192     FMethod = Method;

   193 }

   194 

   195 void JavaMethod::CallVoidMethod(int Count, ...) {

   196     va_list args;

   197     va_start(args, Count);

   198     FEnv->CallVoidMethodV(FObj, FMethod, args);

   199     va_end(args);

   200 

   201     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   202         Messages& messages = Messages::GetInstance();

   203         throw JavaException(FEnv, messages.GetMessage(ERROR_INVOKING_METHOD));

   204     }

   205 }

   206 

   207 JavaMethod::operator jmethodID () {

   208     return FMethod;

   209 }

   210 

   211 //----------------------------------------------------------------------------

   212 

   213 JavaClass::JavaClass(JNIEnv *Env, TString Name) {

   214     FEnv = Env;

   215     FClassName = Name;

   216     FClass = FEnv->FindClass(PlatformString(FClassName));

   217 

   218     if (FClass == NULL || FEnv->ExceptionCheck() == JNI_TRUE) {

   219         Messages& messages = Messages::GetInstance();

   220         TString message = messages.GetMessage(CLASS_NOT_FOUND);

   221         message = PlatformString::Format(message, FClassName.data());

   222         throw JavaException(FEnv, message);

   223     }

   224 }

   225 

   226 JavaClass::~JavaClass() {

   227     FEnv->DeleteLocalRef(FClass);

   228 }

   229 

   230 JavaStaticMethod JavaClass::GetStaticMethod(TString Name, TString Signature) {

   231     jmethodID method = FEnv->GetStaticMethodID(FClass, PlatformString(Name),

   232             PlatformString(Signature));

   233 

   234     if (method == NULL || FEnv->ExceptionCheck() == JNI_TRUE) {

   235         Messages& messages = Messages::GetInstance();

   236         TString message = messages.GetMessage(METHOD_NOT_FOUND);

   237         message = PlatformString::Format(message, Name.data(),

   238                 FClassName.data());

   239         throw JavaException(FEnv, message);

   240     }

   241 

   242     return JavaStaticMethod(FEnv, FClass, method);

   243 }

   244 

   245 JavaClass::operator jclass () {

   246     return FClass;

   247 }

   248 

   249 //----------------------------------------------------------------------------

   250 

   251 void JavaStringArray::Initialize(size_t Size) {

   252     JavaClass jstringClass(FEnv, _T("java/lang/String"));

   253 

   254     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   255         Messages& messages = Messages::GetInstance();

   256         TString message = messages.GetMessage(CLASS_NOT_FOUND);

   257         message = PlatformString::Format(message, _T("String"));

   258         throw JavaException(FEnv, message.data());

   259     }

   260 

   261     jstring str = PlatformString("").toJString(FEnv);

   262     FData = (jobjectArray)FEnv->NewObjectArray((jsize)Size, jstringClass, str);

   263 

   264     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   265         throw JavaException(FEnv, _T("Error"));

   266     }

   267 }

   268 

   269 JavaStringArray::JavaStringArray(JNIEnv *Env, size_t Size) {

   270     FEnv = Env;

   271     Initialize(Size);

   272 }

   273 

   274 JavaStringArray::JavaStringArray(JNIEnv *Env, jobjectArray Data) {

   275     FEnv = Env;

   276     FData = Data;

   277 }

   278 

   279 JavaStringArray::JavaStringArray(JNIEnv *Env, std::list<TString> Items) {

   280     FEnv = Env;

   281     Initialize(Items.size());

   282     unsigned int index = 0;

   283 

   284     for (std::list<TString>::const_iterator iterator = Items.begin();

   285             iterator != Items.end(); iterator++) {

   286         TString item = *iterator;

   287         SetValue(index, PlatformString(item).toJString(FEnv));

   288         index++;

   289     }

   290 }

   291 

   292 jobjectArray JavaStringArray::GetData() {

   293     return FData;

   294 }

   295 

   296 void JavaStringArray::SetValue(jsize Index, jstring Item) {

   297     FEnv->SetObjectArrayElement(FData, Index, Item);

   298 

   299     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   300         throw JavaException(FEnv, _T("Error"));

   301     }

   302 }

   303 

   304 jstring JavaStringArray::GetValue(jsize Index) {

   305     jstring result = (jstring)FEnv->GetObjectArrayElement(FData, Index);

   306 

   307     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   308         throw JavaException(FEnv, _T("Error"));

   309     }

   310 

   311     return result;

   312 }

   313 

   314 unsigned int JavaStringArray::Count() {

   315     unsigned int result = FEnv->GetArrayLength(FData);

   316 

   317     if (FEnv->ExceptionCheck() == JNI_TRUE) {

   318         throw JavaException(FEnv, _T("Error"));

   319     }

   320 

   321     return result;

   322 }