diff -r e8e63152f320 -r 2a9601315dfc javaruntimes/midp/runtime/src/runtimenative.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaruntimes/midp/runtime/src/runtimenative.cpp Mon May 03 12:27:20 2010 +0300 @@ -0,0 +1,367 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Native methods of the MIDP runtime. + * +*/ + + +#include +#include + +#include "exceptionbase.h" +#include "javacommonutils.h" +#include "javainifileutils.h" +#include "javajniutils.h" +#include "javaoslayer.h" +#include "logger.h" +#include "javauid.h" + +#include "platformimpl.h" + +#include "midpruntimeinternalsupport.h" + +#include "commsclientendpoint.h" +#include "commsmessage.h" + +#include "midpauthenticationmodule.h" + +#include "platformrequestinterface.h" + +#include "com_nokia_mj_impl_rt_main_Main.h" +#include "com_nokia_mj_impl_rt_midp_DrmUtil.h" +#include "com_nokia_mj_impl_rt_midp_MidletLifeCycle.h" +#include "com_nokia_mj_impl_rt_midp_MemoryLogger.h" +#include "com_nokia_mj_impl_rt_midp_RuntimeErrorDialog.h" +#include "javax_microedition_midlet_MIDlet.h" + +/** + * A collection of MIDP runtime native methods. + */ + +using namespace java::util; +using namespace java::runtime; + + +/** + * A method for informing native starter about the UID of the MIDlet. This + * is used when UID is received in Java part in pre warm start. The native + * starter needs the UID in order to be able to serve AppilcationInfo + * native interface. + * @param jmuid UID of the MIDlet as String + * @param jmsuid UID of the MIDlet suite as String + * @param handle A pointer to native starter. + */ +JNIEXPORT +void JNICALL Java_com_nokia_mj_impl_rt_midp_MidletLifeCycle__1setUids +(JNIEnv* env, jobject /*obj*/, jstring jmuid, jstring jmsuid, jint handle) +{ + JELOG2(EJavaRuntime); + + // Send the UID to native. + Uid midletUid(JniUtils::jstringToWstring(env, jmuid)); + Uid midletSuiteUid(JniUtils::jstringToWstring(env, jmsuid)); + + try + { + MidpStarterInternalSupport* starter = + reinterpret_cast(handle); + + starter->setUids(midletUid, midletSuiteUid); + } + + catch (ExceptionBase& ex) + { + ELOG1(EJavaRuntime,"ERROR in setting UID. ExceptionBase: %s", + ex.toString().c_str()); + } + catch (std::exception& e) + { + + ELOG1(EJavaRuntime,"ERROR in setting UID. std::exception: %s", + e.what()); + } +} + +/** + * A method for informing native starter that a application* is about to close. + * @param handle A pointer to native starter. + */ +void closeIndImpl(jint handle) +{ + JELOG2(EJavaRuntime); +// throw -1; + try + { + MidpStarterInternalSupport* starter = + reinterpret_cast(handle); + + starter->closeRuntimeInd(); + } + catch (ExceptionBase& ex) + { + ELOG1(EJavaRuntime,"ERROR in close ind. ExceptionBase: %s", + ex.toString().c_str()); + } + catch (std::exception& e) + { + + ELOG1(EJavaRuntime,"ERROR in close ind. std::exception: %s", + e.what()); + } +} + +/** + * A method for informing native starter that a application* is about to close. + * @param handle A pointer to native starter. + */ +JNIEXPORT +void JNICALL Java_com_nokia_mj_impl_rt_main_Main__1closeInd +(JNIEnv* /*env*/, jclass /*peer*/, jint handle) +{ + JELOG2(EJavaRuntime); + closeIndImpl(handle); +} + +/** + * A method for informing native starter that a MIDlet is entered into + * destroyed state. + * @param handle A pointer to native starter. + */ +JNIEXPORT +void JNICALL Java_com_nokia_mj_impl_rt_midp_MidletLifeCycle__1closeInd +(JNIEnv* /*env*/, jclass /*peer*/, jint handle) +{ + JELOG2(EJavaRuntime); + closeIndImpl(handle); +} + +/** + * Consume the rigth objects of the MIDlet if needed. + * @param uri Uri to the platform request handler. + * @param drmContentId Content id of the file. + * @param startPhase true if starting the MIDlet, false on closing. + * @param handle A handle to platform dependent object. Must be 0 on MIDlet + * start and valid pointer on MIDlet stop. On success start case + * the valid handle is reurned into Java side. + * @return Integer object containing valid pointer to native object and + * String containing error string in failure cases. + */ +JNIEXPORT +jobject JNICALL Java_com_nokia_mj_impl_rt_midp_DrmUtil__1consumeRights +(JNIEnv* env, jclass, jstring uri, jstring drmContentId, jboolean startPhase, + jint handle) +{ + JELOG2(EJavaRuntime); + + std::string status; + try + { + consumeRigthsImpl(JniUtils::jstringToWstring(env, uri), + JniUtils::jstringToWstring(env, drmContentId), + status, startPhase, handle); + } + catch (ExceptionBase& ex) + { + ELOG1(EJavaRuntime, "ERROR in PlatformRequest: ExceptionBase: %s", + ex.toString().c_str()); + status = "Internal error"; + } + catch (std::exception& e) + { + status = "Internal Error"; + ELOG1(EJavaRuntime,"ERROR in PlatformRequest. std::exception: %s", + e.what()); + } + if (status.length() == 0) + { + jclass integerClass = env->FindClass("java/lang/Integer"); + if (integerClass != 0) + { + jmethodID constructor = + env->GetMethodID(integerClass, "", "(I)V"); + if (integerClass != 0) + { + return env->NewObject(integerClass, constructor, handle); + } + else + { + status = "J2ME internal error (DRM 1)"; + } + } + else + { + status = "J2ME internal error (DRM 2)"; + } + ELOG(EJavaRuntime, status.c_str()); + } + return env->NewStringUTF(status.c_str()); +} + +/** + * A method for informing native starter about the UID of the MIDlet. This + * is used when UID is received in Java part in pre warm start. The native + * starter needs the UID in order to be able to serve AppilcationInfo + * native interface. + * @param juid UID of the MIDlet as String + * @param handle A pointer to native starter. + */ +JNIEXPORT +void JNICALL Java_com_nokia_mj_impl_rt_midp_MidletLifeCycle__1restoreNormalProcessPriority +(JNIEnv* /*env*/, jobject /*obj*/) +{ + JELOG2(EJavaRuntime); +#ifdef __SYMBIAN32__ + RProcess proc; + proc.SetPriority(EPriorityForeground); +#endif // __SYMBIAN32__ +} +/** + * Do the platform request. + * @param uri Uri to the platform request handler. + */ +JNIEXPORT +void JNICALL Java_javax_microedition_midlet_MIDlet__1managePlatformRequest +(JNIEnv* env, jobject, jstring uri) +{ + JELOG2(EJavaRuntime); + + try + { + std::auto_ptr + handler(getPlatformRequestHandlerObj()); + if (handler.get()) + { + handler->handleUri(JniUtils::jstringToWstring(env,uri)); + } + else + { + JniUtils::throwNewException(env, + "javax/microedition/io/ConnectionNotFoundException", + "URL parsing failed"); + } + } + catch (ExceptionBase& ex) + { + ELOG1(EJavaRuntime, "ERROR in PlatformRequest: ExceptionBase: %s", + ex.toString().c_str()); + if (PlatformRequestInterface::CONNECTION_NOT_SUPPORTED == ex.mErrCode) + { + JniUtils::throwNewException(env, + "javax/microedition/io/ConnectionNotFoundException", + "Unsupported scheme"); + } + else + { + JniUtils::throwNewException(env, + "javax/microedition/io/ConnectionNotFoundException", + ex.toString()); + } + } + catch (std::exception& e) + { + ELOG1(EJavaRuntime,"ERROR in PlatformRequest. std::exception: %s", + e.what()); + } +} + +/** + * A utility for writing the heap size into a file. + * @param file A file to be written in. + * @param heapSize The heap size in bytes. + */ +JNIEXPORT void JNICALL Java_com_nokia_mj_impl_rt_midp_MemoryLogger__1writeFile( + JNIEnv* jniEnv, jobject, jstring file, jint heapSize) +{ + JELOG2(EJavaRuntime); + try + { + jboolean iscopy; + const char* fileName = jniEnv->GetStringUTFChars(file, &iscopy); + LOG2(EJavaRuntime, EInfo, "Writing heap size %d to file %s.", heapSize, fileName); + + std::ofstream heapFile; + heapFile.open(fileName); + heapFile << heapSize; + heapFile.close(); + jniEnv->ReleaseStringUTFChars(file, fileName); + + } + + catch (ExceptionBase& ex) + { + ELOG1(EJavaRuntime,"ERROR in write file. ExceptionBase: %s", + ex.toString().c_str()); + } + catch (std::exception& e) + { + ELOG1(EJavaRuntime,"ERROR in write file. std::exception: %s", + e.what()); + } +} + +/** + * A utility for reading the heap size from a file. + * @param file A file to be read from. + * @retrun heapSize The heap size in bytes. + */ +JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_rt_midp_MemoryLogger__1readFile( + JNIEnv* jniEnv, jclass, jstring file) +{ + JELOG2(EJavaRuntime); + jint heapSize = 0; + try + { + jboolean iscopy; + const char* fileName = jniEnv->GetStringUTFChars(file, &iscopy); + + std::ifstream heapFile; + heapFile.open(fileName, std::ifstream::in); + heapFile >> heapSize; + heapFile.close(); + jniEnv->ReleaseStringUTFChars(file, fileName); + LOG2(EJavaRuntime, EInfo, "Heap size %d read from file %s.", heapSize, fileName); + } + + catch (ExceptionBase& ex) + { + ELOG1(EJavaRuntime,"ERROR in read file. ExceptionBase: %s", + ex.toString().c_str()); + } + catch (std::exception& e) + { + ELOG1(EJavaRuntime,"ERROR in read file. std::exception: %s", + e.what()); + } + return heapSize; +} + +/** + * A utility for getting the stack trace for further processing. + * destroyed state. + * @param handle A pointer to native starter. + */ +JNIEXPORT void JNICALL +Java_com_nokia_mj_impl_rt_midp_RuntimeErrorDialog__1getStackTrace +(JNIEnv* jniEnv, jclass, jthrowable th, jobject printStream) +{ + /* + * call Throwable.printStackTrace(java.io.PrintStream) + * this method is not part of CLDC spec, but it's supported by VM vendors + */ + jclass classThrowable = jniEnv->GetObjectClass(th); + jmethodID methodId = jniEnv->GetMethodID(classThrowable, "printStackTrace", + "(Ljava/io/PrintStream;)V"); + jniEnv->CallVoidMethod(th, methodId, printStream); +} +