diff -r e8e63152f320 -r 2a9601315dfc javatools/javacaptain_app/src.s60/javacap.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javatools/javacaptain_app/src.s60/javacap.cpp Mon May 03 12:27:20 2010 +0300 @@ -0,0 +1,685 @@ +/* +* 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 +#include + +#include "javastoragenames.h" // Storage constants. +#include "securitystoragedatadefs.h" + +#include + +_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(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); + + switch (aCommand) + { + case EAknSoftkeyExit: + case EEikCmdExit: + Exit(); + break; + case ECaptainStart: + { + RProcess proc; + int st = proc.Create(KExecutableName, KExecutableName); + if (st == KErrNone) + { + proc.Resume(); + iAppView->setCaptainState(true); + } + proc.Close(); + } + break; + + case ECaptainStop: + { + CommsMessage message; + message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C); + message.setMessageId(CORE_MSG_ID_STOP_JAVACAPTAIN); + CommsClientEndpoint comms; + comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C); + comms.send(message); + comms.disconnect(); + iAppView->setCaptainState(false); + } + break; + + case EThreadDump: + { + CommsMessage message; + message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C); + message.setMessageId(CORE_MSG_ID_DO_THREAD_DUMP); + CommsClientEndpoint comms; + comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C); + comms.send(message); + comms.disconnect(); + } + break; + + case ETogglePrewarmEnable: + case ETogglePrewarmUiEnable: + case EDebugMode: + case ESecurityMode: + case ES60SecurityPolicy: + case EMSASecurityPolicy: + case EATTSecurityPolicy: + case ERedirectMode: + iAppView->handleStateChangeCmd(aCommand); + break; + + default: + Exit(); + break; + } +} + +CEikAppUi* CJavaCaptainEikDocument::CreateAppUiL() +{ + JELOG2(EJavaCaptain); + return(new(ELeave) CJavaCaptainAppUi); +} + +void CJavaCaptainEikDocument::ConstructL() +{ + JELOG2(EJavaCaptain); +} + +TUid CJavaCaptainApplication::AppDllUid() const +{ + JELOG2(EJavaCaptain); + return KUidJavaCaptain; +} + +CApaDocument* CJavaCaptainApplication::CreateDocumentL() +{ + JELOG2(EJavaCaptain); + CJavaCaptainEikDocument* document=new(ELeave) CJavaCaptainEikDocument(*this); + CleanupStack::PushL(document); + document->ConstructL(); + CleanupStack::Pop(); + return(document); +} + +#include + +LOCAL_C CApaApplication* NewApplication() +{ + JELOG2(EJavaCaptain); + return new CJavaCaptainApplication; +} + + +GLDEF_C TInt E32Main() +{ + JELOG2(EJavaCaptain); + return EikStart::RunApplication(NewApplication); +} + + +#include +#include +#include + +LogRedirector::LogRedirector() : mFd(-1) +{ + iJavaDiagnostic.reset(JavaDiagnostic::createInstance()); +} + +LogRedirector::~LogRedirector() +{ +} + +void LogRedirector::start() +{ + iJavaDiagnostic->setDiagnosticListener(*this); + mFd = open("c:\\data\\javaredirect.log", O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR); +} + +void LogRedirector::stop() +{ + iJavaDiagnostic->removeDiagnosticListener(); + close(mFd); + mFd = -1; +} + +void LogRedirector::systemOut(const TDesC8& aData) +{ + write(aData); +} + +void LogRedirector::systemErr(const TDesC8& aData) +{ + write(aData); +} + +void LogRedirector::log(const TDesC8& aData) +{ + write(aData); +} + +void LogRedirector::write(const TDesC8& aData) +{ + if (mFd > 0) + { + ::write(mFd, (const char*)aData.Ptr(), aData.Size()); + } +}; + + + +// End of File