/*

* 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 <iostream>

#include <fstream>

#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<MidpStarterInternalSupport*>(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<MidpStarterInternalSupport*>(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, "<init>", "(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<PlatformRequestInterface>

        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);

}