/*

* Copyright (c) 2005-2006 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:  General methods

*

*/

// INCLUDE FILES

#include <s32strm.h> // RWriteStream

#ifdef M2G_INFO_POPUP

#include <eikenv.h> // CEikonEnv::InfoWinL

#endif

#include <jni.h>

#include <SvgJavaInterfaceImpl.h>

#include "M2GGeneral.h"

M2G_NS_START

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// -----------------------------------------------------------------------------

// M2GGeneral::RaiseException

// -----------------------------------------------------------------------------

void M2GGeneral::RaiseException(

    JNIEnv* aEnv, const TDesC8& aName, const TUint8* aMsg)

{

    M2G_DEBUG_0("#### M2G_DEBUG: M2GGeneral::RaiseException() ####");

    if (aEnv)

    {

        jclass clazz = aEnv->FindClass(

                           REINTERPRET_CAST(const char*, aName.Ptr()));

        if (!clazz)

        {

            // if exception class not found, then use java.lang.Exception

            clazz = aEnv->FindClass(

                        REINTERPRET_CAST(const char*, KJavaExceptionClass().Ptr()));

        }

        aEnv->ThrowNew(clazz, REINTERPRET_CAST(const char*, aMsg));

    }

}

// -----------------------------------------------------------------------------

// M2GGeneral::CheckErrorCode

// -----------------------------------------------------------------------------

TInt M2GGeneral::CheckErrorCode(JNIEnv* aEnv, TInt aErrorCode)

{

    M2G_DEBUG_1("M2G_DEBUG: M2GGeneral::CheckErrorCode: %d - begin", aErrorCode);

    TInt code = aErrorCode;

    const TUint8* msg = (STATIC_CAST(const TDesC8&, KM2GEmptyString8)).Ptr();

    jcfcommon::auto_ptr<MJavaError> error;

    // Check if an error object

    if (aErrorCode > 0)

    {

        M2G_DEBUG_0("M2G_DEBUG: M2GGeneral::CheckErrorCode(), is MJavaError");

        // Error object need to be deleted here and the auto_ptr takes care of that!!

        error.reset(JavaUnhand< MJavaError >(aErrorCode));

        // Get an error description through the MJavaError object

        msg = error->Description().Ptr();

        switch (error->ErrorCode())

        {

        case KM2GIOException:

        {

            code = error->ErrorCode();

        }

        default:

        {

            code = error->ErrorCode();

        }

        }

        M2G_DEBUG_1("M2G_DEBUG: M2GGeneral::CheckErrorCode(), MJavaError: error code=%d", code);

    }

    switch (code)

    {

    case KM2GMemoryNotOk:

    {

        M2G_DEBUG_0("#### M2G_DEBUG: M2GGeneral::CheckErrorCode() - OutOfMemoryError ####");

        M2GGeneral::RaiseException(aEnv, KJavaOutOfMemoryErrorClass, msg);

        return code;

    }

    case KM2GIOException:

    {

        M2G_DEBUG_0("#### M2G_DEBUG: M2GGeneral::CheckErrorCode() - IOException ####");

        M2GGeneral::RaiseException(aEnv, KJavaIOExceptionClass, msg);

        return code;

    }

    case KM2GHandleNotOk:

    {

        M2G_DEBUG_0("#### M2G_DEBUG: M2GGeneral::CheckErrorCode() - NullPointerException ####");

        M2GGeneral::RaiseException(aEnv, KJavaNullPointerException, msg);

        return code;

    }

    default:

    {

        M2G_DEBUG_1("M2G_DEBUG: M2GGeneral::CheckErrorCode() error code=%d - end", code);

        return code;

    }

    }

}

// -----------------------------------------------------------------------------

// M2GGeneral::CheckHandle

// -----------------------------------------------------------------------------

TInt M2GGeneral::CheckHandle(JNIEnv* aEnv, TInt aHandle)

{

    if (aHandle == M2G_INVALID_HANDLE)

    {

        M2GGeneral::RaiseException(aEnv, KJavaNullPointerException);

    }

    if (aHandle < 0)

    {

        M2GGeneral::CheckErrorCode(aEnv, aHandle);

    }

    return aHandle;

}

// -----------------------------------------------------------------------------

// M2GGeneral::CheckErrorCodeAndHandle

// -----------------------------------------------------------------------------

TInt M2GGeneral::CheckErrorCodeAndHandle(

    JNIEnv* aEnv, TInt aErrorCode, TInt aHandle, TInt aErrorResult)

{

    if ((aErrorCode == KM2GOk) && (aHandle != M2G_INVALID_HANDLE))

    {

        return aHandle;

    }

    if (aErrorCode != KM2GOk)

    {

        M2GGeneral::CheckErrorCode(aEnv, aErrorCode);

    }

    else if (aHandle == M2G_INVALID_HANDLE)

    {

        M2GGeneral::RaiseException(aEnv, KJavaOutOfMemoryErrorClass);

    }

    return aErrorResult;

}

// -----------------------------------------------------------------------------

// M2GGeneral::PopupInfo

// -----------------------------------------------------------------------------

#ifdef M2G_INFO_POPUP

void M2GGeneral::PopupInfo(

    const TDesC& aLine1,

    const TDesC& aLine2)

{

    TInt err = KM2GOk;

    TRAP(err, CEikonEnv::InfoWinL(aLine1, aLine2));

    if (err == KM2GOk)

    {

        // DUMMY

    }

}

#endif // M2G_INFO_POPUP

#ifdef M2G_STATISTIC_DEBUG

// -----------------------------------------------------------------------------

// M2GGeneral::TM2GStatistic::TM2GStatistic

// -----------------------------------------------------------------------------

M2GGeneral::TM2GStatistic::TM2GStatistic()

{

    Reset();

}

// -----------------------------------------------------------------------------

// M2GGeneral::TM2GStatistic::Reset()

// -----------------------------------------------------------------------------

void M2GGeneral::TM2GStatistic::Reset()

{

    // Time

    iStartTime.UniversalTime();

    iEndTime.UniversalTime();

    // Thread

    iId = RThread().Id();

    RThread thread;

    if (thread.Open(iId) == KM2GOk)

    {

        iThreadName = thread.Name();

        thread.Close();

    }

}

// -----------------------------------------------------------------------------

// M2GGeneral::TM2GStatistic::Print()

// -----------------------------------------------------------------------------

void M2GGeneral::TM2GStatistic::Print(TBool aPrintElapsedTime)

{

    TInt totalRom = 0;

    TInt totalRam = 0;

    TInt freeRam = 0;

    HAL::Get(HALData::EMemoryROM, totalRom);

    HAL::Get(HALData::EMemoryRAM, totalRam);

    HAL::Get(HALData::EMemoryRAMFree, freeRam);

    // Update time

    iEndTime.UniversalTime();

    M2G_DEBUG_0("====================================================");

    // Write memory info

    if (aPrintElapsedTime)

    {

        M2G_DEBUG_5(

            "Rom size:%d, ram size:%d, ram free:%d, ram used:%d, elapsed time:%d",

            totalRom >> 10,

            totalRam >> 10,

            freeRam >> 10,

            (totalRam - freeRam) >> 10,

            iEndTime.MicroSecondsFrom(iStartTime).Int64());

    }

    else

    {

        M2G_DEBUG_4(

            "Rom size:%d, ram size:%d, ram free:%d, ram used:%d",

            totalRom >> 10,

            totalRam >> 10,

            freeRam >> 10,

            (totalRam - freeRam) >> 10);

    }

    // Write thread info

    RThread thread;

    if (thread.Open(iId) == KM2GOk)

    {

        TThreadStackInfo stackInfo;

        thread.StackInfo(stackInfo);

        thread.Close();

        TUint id = iId;

        M2G_DEBUG_2("Thread id:%d, size:%d", id, (stackInfo.iBase - stackInfo.iLimit) >> 10);

    }

    M2G_DEBUG_0("====================================================");

}

// -----------------------------------------------------------------------------

// M2GGeneral::TM2GStatistic::Print()

// -----------------------------------------------------------------------------

void M2GGeneral::TM2GStatistic::Print(RWriteStream& /*aStream*/)

{

}

// -----------------------------------------------------------------------------

// M2GGeneral::TM2GStatistic::Log()

// -----------------------------------------------------------------------------

void M2GGeneral::TM2GStatistic::Log()

{

    M2G_DEBUG_0("M2GGeneral::TM2GStatistic::Log()");

    M2GGeneral::TM2GStatistic statistic;

    statistic.Print();

}

#endif // M2G_STATISTIC_DEBUG

M2G_NS_END