/*

* Copyright (c) 2008 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:  JavaCap

*

*/

#include "comms.h"

#include "rtcmessages.h"

#include "coremessages.h"

#include "logger.h"

#include "javacap.h"

#include "javacap.hrh"

#include "javainifileutils.h"

#include <centralrepository.h>

#include <SWInstallerInternalCRKeys.h>

#include "javastoragenames.h"                   // Storage constants.

#include "securitystoragedatadefs.h"

#include <javacap.rsg>

_LIT(KJavaCapYes, "Yes");

_LIT(KJavaCapNo,  "No");

_LIT(KUserSecurityMode,  "User");

_LIT(KNormalSecurityMode,  "Default");

_LIT(KS60SecurityPolicyName,  "S60");

_LIT(KMSASecurityPolicyName,  "MSA");

_LIT(KATTSecurityPolicyName,  "AT&T");

_LIT(KS60SecurityPolicy,  "s60");

_LIT(KMSASecurityPolicy,  "msa");

_LIT(KATTSecurityPolicy,  "att");

// Java Security Policy Central Repository UID

static const TUid KCRUidJavaSecurity = { 0x2001B289 };

// IDs for security folder and file keys

static const TUint32 KPolicy = 0x03;

static const TUint32 KSecurityWarnings = 0x04;

const int KS60SecurityPolicyId = 1;

const int KMSASecurityPolicyId = 2;

const int KATTSecurityPolicyId = 3;

using namespace java::storage;

using namespace std;

using namespace java::util;

using namespace java::comms;

using namespace java::captain;

void CJavaCaptainContainer::ConstructL(const TRect& aRect)

{

    JELOG2(EJavaCaptain);

    mCaptainRunning = true;

    mPrewarmEnabled = false;

#if defined(RD_JAVA_PREWARM) && !defined (__WINS__)

    mPrewarmEnabled = true;

#endif // RD_JAVA_PREWARM

    mPrewarmUiEnabled = false;

    mDebugEnabled = false;

    mRedirectEnabled = false;

    iStorage.reset(JavaStorage::createInstance());

    try

    {

        iStorage->open();

    }

    catch (JavaStorageException& aJse)

    {

        User::Leave(aJse.mStatus);

    }

    mUserSecurityModeEnabled = (GetSecurityWarningsMode() == SECURITY_WARNINGS_USER_DEFINED_MODE);

    mSecurityPolicyId = GetSecurityPolicy();

    mHeader = _L("Java states:");

    updateStates();

    CreateWindowL();

    SetRect(aRect);

    ActivateL();

    mRedirector.reset(new LogRedirector());

}

CJavaCaptainContainer::~CJavaCaptainContainer()

{

    JELOG2(EJavaCaptain);

}

void CJavaCaptainContainer::Draw(const TRect& /*aRect*/) const

{

    JELOG2(EJavaCaptain);

    CWindowGc& gc = SystemGc();

    gc.Clear();

    const CFont* usedFont = CEikonEnv::Static()->NormalFont();

    gc.UseFont(usedFont);

    gc.DrawText(mHeader,TPoint(10,20));

    int pos = 50;

    gc.DrawText(mCaptainState,TPoint(20,pos));

    int gap = 25;

    pos += gap;

    gc.DrawText(mPrewarmState,TPoint(20,pos));

    pos += gap;

    gc.DrawText(mPrewarmUiState,TPoint(20,pos));

    pos += gap;

    gc.DrawText(mDebugState,TPoint(20,pos));

    pos += gap;

    gc.DrawText(mSecurityMode,TPoint(20,pos));

    pos += gap;

    gc.DrawText(mSecurityPolicy,TPoint(20,pos));

    pos += gap;

    gc.DrawText(mRedirectState,TPoint(20,pos));

    gc.DiscardFont();

}

void CJavaCaptainContainer::updateStates()

{

    int propertyVal = java::util::JavaIniFileUtils::getProperty(java::util::UI_PREWARM);

    if (propertyVal != -1)

    {

        mPrewarmUiEnabled = propertyVal;

    }

    mCaptainState = _L("Captain running:               ");

    if (mCaptainRunning)

    {

        mCaptainState.Append(KJavaCapYes);

    }

    else

    {

        mCaptainState.Append(KJavaCapNo);

    }

    mPrewarmState = _L("Prewarm enabled:           ");

    if (mPrewarmEnabled)

    {

        mPrewarmState.Append(KJavaCapYes);

    }

    else

    {

        mPrewarmState.Append(KJavaCapNo);

    }

    mPrewarmUiState = _L("Prewarm UI enabled:      ");

    if (mPrewarmUiEnabled)

    {

        mPrewarmUiState.Append(KJavaCapYes);

    }

    else

    {

        mPrewarmUiState.Append(KJavaCapNo);

    }

    mDebugState = _L("Java Debug enabled:      ");

    if (mDebugEnabled)

    {

        mDebugState.Append(KJavaCapYes);

    }

    else

    {

        mDebugState.Append(KJavaCapNo);

    }

    mSecurityMode = _L("Security warnings:      ");

    if (mUserSecurityModeEnabled)

    {

        mSecurityMode.Append(KUserSecurityMode);

    }

    else

    {

        mSecurityMode.Append(KNormalSecurityMode);

    }

    mSecurityPolicy = _L("Security policy:      ");

    switch (mSecurityPolicyId)

    {

    case KS60SecurityPolicyId:

        mSecurityPolicy.Append(KS60SecurityPolicyName);

        break;

    case KMSASecurityPolicyId:

        mSecurityPolicy.Append(KMSASecurityPolicyName);

        break;

    case KATTSecurityPolicyId:

        mSecurityPolicy.Append(KATTSecurityPolicyName);

        break;

    default:

        mSecurityPolicy.Append(KS60SecurityPolicyName);

    }

    mRedirectState = _L("Redirect logs:                   ");

    if (mRedirectEnabled)

    {

        mRedirectState.Append(KJavaCapYes);

    }

    else

    {

        mRedirectState.Append(KJavaCapNo);

    }

    DrawDeferred();

}

void CJavaCaptainContainer::setCaptainState(bool running)

{

    mCaptainRunning = running;

    updateStates();

}

#include "commsmessage.h"

#include "commsclientendpoint.h"

void CJavaCaptainContainer::handleStateChangeCmd(int cmd)

{

    switch (cmd)

    {

    case ETogglePrewarmEnable:

    {

        mPrewarmEnabled = !mPrewarmEnabled;

        CommsMessage message;

        message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C);

        if (mPrewarmEnabled)

        {

            message.setMessageId(CORE_MSG_ID_START_PREWARM);

        }

        else

        {

            message.setMessageId(CORE_MSG_ID_STOP_PREWARM);

        }

        CommsClientEndpoint comms;

        comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

        comms.send(message);

        comms.disconnect();

        break;

    }

    case ETogglePrewarmUiEnable:

        mPrewarmUiEnabled = !mPrewarmUiEnabled;

        java::util::JavaIniFileUtils::setProperty(java::util::UI_PREWARM, mPrewarmUiEnabled);

        break;

    case EDebugMode:

    {

        mDebugEnabled = !mDebugEnabled;

        CommsMessage message;

        std::wstring vmArgs = L"";

        if (mDebugEnabled)

        {

            vmArgs = L"-Xrunjdwp:server=y,address=localhost:8000";

        }

        setSetExtraArguments(message, vmArgs, L"");

        CommsClientEndpoint comms;

        comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

        comms.send(message);

        comms.disconnect();

    }

    break;

    case ESecurityMode:

    {

        mUserSecurityModeEnabled = !mUserSecurityModeEnabled;

        if (mUserSecurityModeEnabled)

        {

            SetSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE);

        }

        else

        {

            SetSecurityWarningsMode(SECURITY_WARNINGS_DEFAULT_MODE);

        }

    }

    break;

    case ES60SecurityPolicy:

        mSecurityPolicyId = KS60SecurityPolicyId;

        SetSecurityPolicy(mSecurityPolicyId);

        break;

    case EMSASecurityPolicy:

        mSecurityPolicyId = KMSASecurityPolicyId;

        SetSecurityPolicy(mSecurityPolicyId);

        break;

    case EATTSecurityPolicy:

        mSecurityPolicyId = KATTSecurityPolicyId;

        SetSecurityPolicy(mSecurityPolicyId);

        break;

    case ERedirectMode:

        mRedirectEnabled = !mRedirectEnabled;

        if (mRedirectEnabled)

        {

            mRedirector->start();

        }

        else

        {

            mRedirector->stop();

        }

        break;

    default:

        break;

    }

    updateStates();

}

std::wstring CJavaCaptainContainer::GetSecurityWarningsMode()

{

    try

    {

        JavaStorageApplicationEntry_t query;

        JavaStorageApplicationList_t queryResult;

        JavaStorageEntry attr;

        attr.setEntry(ID, L"");

        query.insert(attr);

        attr.setEntry(SECURITY_WARNINGS, L"");

        query.insert(attr);

        iStorage->search(MIDP_PACKAGE_TABLE, query, queryResult);

        JavaStorageApplicationList_t::const_iterator iterator;

        JavaStorageApplicationList_t domainQueryResult;

        for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++)

        {

            std::wstring securityWarnings = L"";

            JavaStorageApplicationEntry_t entry = (*iterator);

            findColumn(entry, SECURITY_WARNINGS, securityWarnings);

            if (securityWarnings == SECURITY_WARNINGS_USER_DEFINED_MODE)

            {

                // make them all USER

                SetSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE);

                return SECURITY_WARNINGS_USER_DEFINED_MODE;

            }

        }

    }

    catch (JavaStorageException& aJse)

    {

    }

    // one mroe check: central repository

    std::wstring securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE;

    TRAP_IGNORE(

        CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

        TInt warningsMode;

        User::LeaveIfError(repository->Get(KSecurityWarnings, warningsMode));

        switch (warningsMode)

{

case 1:

    securityWarningsMode = SECURITY_WARNINGS_USER_DEFINED_MODE;

    break;

case 2:

    securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE;

    break;

}

CleanupStack::PopAndDestroy(repository););

    return securityWarningsMode;

}

void CJavaCaptainContainer::SetSecurityWarningsMode(const std::wstring& aSecurityWarningsMode)

{

    try

    {

        JavaStorageApplicationEntry_t query;

        JavaStorageApplicationList_t queryResult;

        JavaStorageEntry attr;

        attr.setEntry(ID, L"");

        query.insert(attr);

        iStorage->search(MIDP_PACKAGE_TABLE, query, queryResult);

        JavaStorageApplicationList_t::const_iterator iterator;

        JavaStorageApplicationList_t domainQueryResult;

        for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++)

        {

            std::wstring uid = L"";

            JavaStorageApplicationEntry_t entry = (*iterator);

            findColumn(entry, ID, uid);

            JavaStorageApplicationEntry_t oldEntry;

            JavaStorageEntry oldAttr;

            oldAttr.setEntry(ID, uid);

            oldEntry.insert(oldAttr);

            attr.setEntry(SECURITY_WARNINGS, aSecurityWarningsMode);

            entry.clear();

            entry.insert(attr);

            iStorage->update(MIDP_PACKAGE_TABLE, entry, oldEntry);

        }

    }

    catch (JavaStorageException& aJse)

    {

    }

    // set the cenRep key as well

    TRAP_IGNORE(

        CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

        if (aSecurityWarningsMode == SECURITY_WARNINGS_USER_DEFINED_MODE)

{

    repository->Set(KSecurityWarnings, 1);

    }

    else

    {

        repository->Set(KSecurityWarnings, 2);

    }

    CleanupStack::PopAndDestroy(repository);

    );

}

void  CJavaCaptainContainer::findColumn(const JavaStorageApplicationEntry_t& aEntry,

                                        const wstring& aColName, wstring& aColValue)

{

    JavaStorageEntry findPattern;

    findPattern.setEntry(aColName, L"");

    JavaStorageApplicationEntry_t::const_iterator findIterator =

        aEntry.find(findPattern);

    if (findIterator != aEntry.end())

    {

        aColValue = findIterator->entryValue();

    }

}

int CJavaCaptainContainer::GetSecurityPolicy()

{

    int securityPolicyId =KS60SecurityPolicyId;

    TRAP_IGNORE(

        CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

        HBufC* buf = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);

        TPtr policy(buf->Des());

        User::LeaveIfError(repository->Get(KPolicy, policy));

        if (policy.Compare(KS60SecurityPolicy) == 0)

{

    securityPolicyId = KS60SecurityPolicyId;

}

else if (policy.Compare(KMSASecurityPolicy) == 0)

{

    securityPolicyId = KMSASecurityPolicyId;

}

else if (policy.Compare(KATTSecurityPolicy) == 0)

{

    securityPolicyId = KATTSecurityPolicyId;

}

CleanupStack::PopAndDestroy(buf);

CleanupStack::PopAndDestroy(repository););

    return securityPolicyId;

}

void CJavaCaptainContainer::SetSecurityPolicy(int aSecurityPolicyId)

{

    TRAP_IGNORE(

        CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

        switch (aSecurityPolicyId)

{

case KS60SecurityPolicyId:

    User::LeaveIfError(repository->Set(KPolicy, KS60SecurityPolicy));

        break;

    case KMSASecurityPolicyId:

        User::LeaveIfError(repository->Set(KPolicy, KMSASecurityPolicy));

        break;

    case KATTSecurityPolicyId:

        User::LeaveIfError(repository->Set(KPolicy, KATTSecurityPolicy));

        break;

    }

    CleanupStack::PopAndDestroy(repository););

}

//

// CJavaCaptainAppUi

//

CJavaCaptainAppUi::~CJavaCaptainAppUi()

{

    JELOG2(EJavaCaptain);

    RemoveFromStack(iAppView);

    delete iAppView;

    delete mPeriodic;

}

void CJavaCaptainAppUi::ConstructL()

{

    JELOG2(EJavaCaptain);

    BaseConstructL();

    iAppView=new(ELeave) CJavaCaptainContainer;

    iAppView->SetMopParent(this);

    iAppView->ConstructL(ClientRect());

    iCoeEnv->RootWin().EnableFocusChangeEvents();

    mPeriodic=CPeriodic::NewL(CActive::EPriorityStandard);

    AddToStackL(iAppView);

}

_LIT(KExecutableName, "javacaptain.exe");

void senMsgToSplash(int id)

{

    CommsMessage message;

    message.setModuleId(1);

    message.setMessageId(id);

    CommsClientEndpoint comms;

    comms.connect(10900);

    comms.send(message);

    comms.disconnect();

}

TInt CJavaCaptainAppUi::tick(TAny* appUi)

{

    CJavaCaptainAppUi* app = static_cast<CJavaCaptainAppUi*>(appUi);

//    ELOG1(EJavaCaptain,"mActive: %d", app->mActive);

    if (app->mActive)

    {

        senMsgToSplash(1);

    }

    else

    {

        senMsgToSplash(2);

    }

    app->mActive = !app->mActive;

    return 0;

}

void CJavaCaptainAppUi::HandleCommandL(TInt aCommand)

{

    JELOG2(EJavaCaptain);