diff -r b9b00b134b0d -r d316aecb87fd applicationmanagement/server/src/ApplicationManagementServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applicationmanagement/server/src/ApplicationManagementServer.cpp Tue Jul 13 04:01:20 2010 +0530 @@ -0,0 +1,3962 @@ +/* + * Copyright (c) 2000 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: Implementation of applicationmanagement components + * + */ + +#define __INCLUDE_CAPABILITY_NAMES__ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ampskeys.h" +#include "amprivateCRKeys.h" +#include "ApplicationManagementConst.h" +#include "ApplicationManagementCommon.h" +#include "ApplicationManagementClientServer.h" +#include "ApplicationManagementServer.h" +#include "AMDeploymentComponent.h" +#include "amsmlhelper.h" +#include "ApplicationManagementUtility.h" +#include "ApplicationManagementUtilityFactory.h" +#include "debug.h" +#include "coemain.h" +#include "AMPreInstallApp.h" +#include "amview.h" +#include "appmgmtnotifier.h" + +using namespace NApplicationManagement; + +#ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_ + +#pragma message("AM Connecting installer at startup") +#else +#pragma message("AM Connecting installer when needed") +#endif +// Needed only for jad+jar installation +_LIT( KInstallDir, "c:\\temp\\" ); +_LIT8(KMIDletJarURL, "MIDlet-Jar-URL"); +//OMA SCOMO Specific +_LIT8(KDownloadState, "./SCOMO/Download/"); +_LIT8(KDeliveredState, "./SCOMO/Inventory/Delivered/"); +_LIT8(KDeployedState, "./SCOMO/Inventory/Deployed/"); + +//Package all the above together into a policy +CPolicyServer::TPolicy KApplicationManagementSecurityPolicy; + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ComponentDownloadComplete() +// ------------------------------------------------------------------------------------------------ +void CApplicationManagementServer::ComponentDownloadComplete( + CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId) + { + TInt err = KErrNone; + TRAP( err, DownloadCompleteL( aComponent, iapid, aServerId )); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DownloadCompleteL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DownloadCompleteL( + CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId) + { + RDEBUG( "ApplicationManagementServer DownloadComplete - start" ); + __ASSERT_DEBUG( aComponent, User::Invariant() ); + iComp = aComponent; + iStorage->UpdateL(*aComponent); + TInt errdownload = KErrNone; + TInt errInstall = KErrNone; + TInt status = KStatusSuccess; + + if (!aComponent->DownloadFailed()) + { + CDeploymentComponent *old = DoDataUpdateCheckL(*aComponent); + TDownloadTarget trgt = aComponent->DownloadTarget(); + switch (trgt) + { + case EDeliver: + { + break; + } + case EInstall: + case EInstallAndActivate: + { + + TRAP(errInstall,DoTheInstallL( *aComponent)); +RDEBUG_2( "ApplicationManagementServer DownloadComplete - start %d", errInstall); + + if (trgt == EInstall && errInstall == KErrNone) + { + iStorage->DeactivateL(*aComponent); + } + break; + } + + case EUpdate: + case EUpdateAndActivate: + { + if (old) + { + FullUpdateL(*aComponent, *old); + if (trgt == EUpdate) + { + iStorage->DeactivateL(*aComponent); + } + } + break; + } + default: + { + break; + } + } + } + else + { + errdownload = aComponent->DownloadStatus(); + } + + RDEBUG( "ApplicationManagementServer DownloadComplete - Start Send to background" ); + //Download Completed/ Failed or installation success/ failure Send server to Background. + + iOMASCOMOEnabled = IsOMASCOMOEnabledL(); + + m_Window->lower(); + + if (iOMASCOMOEnabled) + { + status = GetErrorStatus(errdownload, errInstall); + + TInt ASyncSupported = -1; + + CRepository *repository = CRepository::NewLC( + KUidPSApplicationManagementKeys); + repository->Get(KAsyncEnabled, ASyncSupported); + CleanupStack::PopAndDestroy(); + + // For Sync Reporting + if (!ASyncSupported) + { + // Update Central Repository with proper error code for Sync + + CRepository *repository = CRepository::NewLC( + KUidPSApplicationManagementKeys); + repository->Set(KAMSyncStatus, status); + CleanupStack::PopAndDestroy(); + + RProperty counter; + + TInt r = counter.Attach(KUidPSApplicationManagementKeys, + KSyncNotifier, EOwnerThread); + User::LeaveIfError(r); + + TInt err = counter.Set(KErrCancel); + User::LeaveIfError(err); + counter.Close(); + } + else// Do AsyncReporting + { + + RDEBUG( "CApplicationManagementServer::ASync Reporting Step 1" ); + + // Get deployement component entries + TInt internalid = aComponent->InternalId(); + + RDEBUG( "CApplicationManagementServer::ASync Reporting Step 2" ); + + TBuf8<256> targetURI; + + TDeploymentComponentState state = aComponent->State(); + + RDEBUG( "CApplicationManagementServer::ASync Reporting Step 3" ); + + if (state == EDCSDownload) + { + + RDEBUG( "CApplicationManagementServer::ASync EDCSDownload Start" ); + + targetURI.Append(KDownloadState); + targetURI.Append(aComponent->UserId()); + + RDEBUG( "CApplicationManagementServer::ASync EDCSDownload End" ); + + } + else if (state == EDCSDelivered) + { + RDEBUG( "CApplicationManagementServer::ASync EDCSDelivered Start" ); + + targetURI.Append(KDeliveredState); + targetURI.Append(aComponent->UserId()); + + RDEBUG( "CApplicationManagementServer::ASync EDCSDelivered End" ); + + } + else if (state == EDCSActive || state == EDCSInactive) + { + + RDEBUG( "CApplicationManagementServer::ASync EDCSActive Start" ); + + targetURI.Append(KDeployedState); + targetURI.Append(aComponent->UserId()); + + RDEBUG( "CApplicationManagementServer::ASync EDCSActive End" ); + } + + //Save Entry to database with status and target URI of deployment component + TInt iapidval = 2; + TRAPD( err1, SmlHelper::GetDefaultIAPFromDMProfileL( iapid ) ); + if (err1 == KErrNone) + { + RDEBUG_2("Application Mgmt Server service::DownloadCompleteL iapid to : %d", iapid ); + } + + TInt index; + iAMServerDB->SaveToDatabaseL(index, internalid, status, + targetURI, iapidval); + + RDEBUG( "CApplicationManagementServer::ASync SaveToDatabaseL completed" ); + + EnableDMNetworkMonL(iapid, aServerId); + } + } + int value = 0 ; + int err = RProperty::Set(TUid::Uid(KOmaDMAppUid), KDownloadActive, value); + RDEBUG_2("RProperty set (%d)", err ); + if (iDownloadMngr->DownloadCount() == 0) + { + + RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", iSessionCount ); + + // Is session count is not modified whenever there is error then at the end of download complete decrement + // the session count. + + if (status != KStatusSuccess && iSessionCount != 0) + { + iSessionCount--; + } + + if (iSessionCount == 0) + { + iShutdown.Start(); + } + } + aComponent->SetDriveSelectionStatus(false); + RDEBUG( "ApplicationManagementServer DownloadComplete - end" ); + } + +void CApplicationManagementServer::InstallationCancelled() + { + iInstaller.CancelOperation(); + } +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::IsOMASCOMOEnabledL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::IsOMASCOMOEnabledL() + { + RDEBUG( "CApplicationManagementServer::IsOMASCOMOEnabledL Start" ); + + TInt adapterValue; + + CRepository *repository = CRepository::NewLC( + KCRUidPrivateApplicationManagementKeys); + repository->Get(KAMAdapterValue, adapterValue); + CleanupStack::PopAndDestroy(); + + RDEBUG( "CApplicationManagementServer::IsOMASCOMOEnabledL End" ); + + if (adapterValue == 0 || adapterValue == 1) + return EFalse; + else + return ETrue; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GetErrorStatus() +// ------------------------------------------------------------------------------------------------ +TInt CApplicationManagementServer::GetErrorStatus(TInt aErrorDownload, + TInt aErrorInstall) + { + TInt status = KStatusSuccess; + + if (aErrorDownload != KErrNone) + { + if (aErrorDownload == KStatusUserCancelled || aErrorDownload + == KStatusDowloadFailedOOM || aErrorDownload + == KStatusUnSupportedEnvironment || aErrorDownload + == KStatusAlternateDownldAuthFail || aErrorDownload + == KStatusAltDowldUnavailable) + { + status = aErrorDownload; + } + else + status = KStatusDownloadFailed; + } + + else if (aErrorInstall != KErrNone) + { + if (aErrorInstall == SwiUI::KSWInstErrSecurityFailure) + status = KStatusPkgValidationFailed; + if (aErrorInstall == SwiUI::KSWInstErrInsufficientMemory) + status = KStatusInstallFailedOOM; + if (aErrorInstall == KStatusUserCancelled) + status = KStatusUserCancelled; + else + status = KStatusInstallFailed; + + } + + return status; + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::EnableDMNetworkMonL() +// ------------------------------------------------------------------------------------------------ +void CApplicationManagementServer::EnableDMNetworkMonL(TInt iapid, + HBufC8 *aServerId) + { + TInt retryenabled = 1; + _LIT( KNetMon,"\\dmnetworkmon.exe" ); + + // Enable DM Network Monitoring for retry of Generic alert in case of N/W loss + + CRepository *repository = CRepository::NewLC( + KCRUidDeviceManagementInternalKeys); + TInt err_val = repository->Set(KDevManEnableDMNetworkMon, retryenabled); + RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL Retry enabled err: %d", err_val ); + RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL Retry enabled value: %d", retryenabled ); + + err_val = repository->Set(KDevManIapIdKey, iapid); + RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL devmaniapid: %d", err_val ); + RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL iap id: %d", iapid ); + + err_val = repository->Set(KDevManServerIdKey, *aServerId); + RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL serveridkey: %d", err_val ); + + TBuf<256> buf1; + buf1.Copy(*aServerId); + RDEBUG_2( "Server ID - '%S'", &buf1); + + CleanupStack::PopAndDestroy(); + + // create NetMon EXE + RProcess rp; + TInt err = rp.Create(KNetMon, KNullDesC); + User::LeaveIfError(err); + TRequestStatus stat; + rp.Rendezvous(stat); + + if (stat != KRequestPending) + rp.Kill(0); // abort startup + else + rp.Resume(); // logon OK - start the server + TInt r = (rp.ExitType() == EExitPanic) ? KErrGeneral : stat.Int(); + rp.Close(); + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CApplicationManagementServer +// ------------------------------------------------------------------------------------------------ + +inline CApplicationManagementServer::CApplicationManagementServer() : + CPolicyServer(0, KApplicationManagementSecurityPolicy, ESharableSessions) + { + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::AddSession() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::AddSession() + { + // A new session is being created + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::AddSession" ); + ++iSessionCount; + + // Cancel the shutdown timer if it was running + iShutdown.Cancel(); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DropSession() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DropSession() + { + // A session is being destroyed + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession" ); + + // Start the shutdown timer if it is the last session + if (--iSessionCount == 0) + { + if (iDownloadMngr->DownloadCount() > 0) + { + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession download in progress" ); + } + else + { + iShutdown.Start(); + } + } + } + +// ----------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::AddDownloadL( CDeploymentComponent *aComponent ) +// ----------------------------------------------------------------------------------------------------------- + +void CApplicationManagementServer::AddDownloadL( + CDeploymentComponent *aComponent) + { + __ASSERT_DEBUG( aComponent, User::Invariant() ); + + RDEBUG( "CApplicationManagementServer::AddDownloadL Start" ); + + iDownloadMngr->AddDownloadL(aComponent); + + RDEBUG( "CApplicationManagementServer::AddDownloadL End" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer +// ----------------------------------------------------------------------------- + +CServer2* CApplicationManagementServer::NewL(HbMainWindow *mainWindow) + { + //specifies all connect attempts should pass + KApplicationManagementSecurityPolicy.iOnConnect + = CPolicyServer::EAlwaysPass; + KApplicationManagementSecurityPolicy.iRangeCount + = KApplicationManagementRangeCount; //number of ranges + KApplicationManagementSecurityPolicy.iRanges + = KApplicationManagementRanges; + KApplicationManagementSecurityPolicy.iElementsIndex + = KApplicationManagementSecurityElementsIndex; + KApplicationManagementSecurityPolicy.iElements + = KApplicationManagementSecurityElements; + + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::NewLC" ); + + CApplicationManagementServer* self = + new (ELeave) CApplicationManagementServer; + CleanupStack::PushL(self); + + self->ConstructL(mainWindow); + CleanupStack::Pop(); + return self; + + } + +// ----------------------------------------------------------------------------- +// CApplicationManagementServer::~CApplicationManagementServer +// ------------------------------------------------------------------------------------------------ + +CApplicationManagementServer::~CApplicationManagementServer() + { + RDEBUG_3("CApplicationManagementServer::~CApplicationManagementServer 0x%X - 0x%X", reinterpret_cast(this ), + reinterpret_cast(this)+sizeof( CApplicationManagementServer ) ); + FeatureManager::UnInitializeLib(); + iInstaller.Close(); + delete iStorage; + + delete iUtility; + delete iAMServerDB; + + RProperty::Delete(KUidPSApplicationManagementKeys, KAMServerUIEnabled); + + RProperty::Delete(KUidPSApplicationManagementKeys, KAMOperationNonSilent); + + RProperty::Delete(KUidPSApplicationManagementKeys, KSyncNotifier); + + RProperty::Delete(KUidPSApplicationManagementKeys, KDMUINotClosed); + + iInstallFile.Close(); + iInstallRFs.Close(); + + delete iDownloadMngr; + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::HandleAllClientsClosed +// ------------------------------------------------------------------------------------------------ +void CApplicationManagementServer::HandleAllClientsClosed() + { + // Do Nothing + RDEBUG( "CApplicationManagementServer::HandleAllClientsClosed" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ConstructL +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::ConstructL(HbMainWindow* aWindow) + { + + // 2nd phase construction - ensure the timer and server objects are running + RDEBUG( "CApplicationManagementServer::ConstructL - Start" ); + + iOMASCOMOEnabled = ETrue; + mUserCancelled = 0; + TRAPD( errf, FeatureManager::InitializeLibL() ); + if (errf != KErrNone) + { + User::Leave(errf); + } + m_Window = aWindow; + RDEBUG( "CApplicationManagementServer::ConstructL - start" ); + StartL(KApplicationManagementServerName); + iStorage = CDeliveryComponentStorage::NewL(); + + iUtility + = ApplicationManagementUtilityFactory::CreateManagementUtilityL(); + iDownloadMngr = CAMDownloadStore::NewL(*this); + iAMServerDB = CAMDownloaddb::NewL(); + + // Define P&S Keys + RProperty::Define(KUidPSApplicationManagementKeys, KAMServerUIEnabled, + RProperty::EInt); + + RProperty::Define(KUidPSApplicationManagementKeys, KAMOperationNonSilent, + RProperty::EInt); + + RProperty::Define(KUidPSApplicationManagementKeys, KSyncNotifier, + RProperty::EInt); + + RProperty::Define(KUidPSApplicationManagementKeys, KDMUINotClosed, + RProperty::EInt); + + RProperty syncproperty; + + //Ignore error status + syncproperty.Attach(KUidPSApplicationManagementKeys, KSyncNotifier, + EOwnerThread); + syncproperty.Set(KErrNone); + syncproperty.Close(); + +#ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_ + TInt err( iInstaller.Connect() ); + if ( err != KErrNone ) + { + RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", err ); + User::LeaveIfError( err ); + } +#endif + iShutdown.ConstructL(); + // ensure that the server still exits even if the 1st client fails to connect + iShutdown.Start(); + + RDEBUG( "CApplicationManagementServer::ConstructL - end" ); + } +//--------------------------------------------------------------------------- +// Create a new client session. +//--------------------------------------------------------------------------- +CSession2* CApplicationManagementServer::NewSessionL( + const TVersion& aVersion, const RMessage2& /*aMessage */) const + { + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::NewSessionL" ); + TVersion ver(KAMVerMajor, KAMVerMinor, KAMVerBuild); + if (!User::QueryVersionSupported(ver, aVersion)) + { + RDEBUG( "CApplicationManagementServer::NewSessionL(): wrong version offered -> BAIL OUT!" ); + User::Leave(KErrNotSupported); + } + return new (ELeave) CApplicationManagementSession(); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CustomSecurityCheckL() +// ------------------------------------------------------------------------------------------------ + +CPolicyServer::TCustomResult CApplicationManagementServer::CustomSecurityCheckL( + const RMessage2& /*aMsg*/, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/) + { + return EPass; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::InstallCompleteL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::InstallCompleteL( + const CDeploymentComponent& aCompo, const TBool &aInstallSuccess) + { + RDEBUG_2("CApplicationManagementServer::InstallCompleteL start (%d)", aInstallSuccess); + + iInstallFile.Close(); + // if java jad + jar install, remove files from c:\temp directory + if (CDeploymentComponent::IsJavaMimeL(aCompo.MetaData().MimeType() ) && CDeploymentComponent::IsJavaMimeL(aCompo.Data().MimeType() ) ) + { + TFileName fn, fn2; + GenerateTempFileNameL(iInstallRFs, aCompo, fn, fn2); + RDEBUG_3("CApplicationManagementServer::InstallCompleteL delete files: (%S) (%S)", &fn, &fn2); + User::LeaveIfError(iInstallRFs.Delete(fn)); + User::LeaveIfError(iInstallRFs.Delete(fn2)); + } + TInt silentsession = 0; + TInt r2 = RProperty::Get(KPSUidNSmlSOSServerKey, KNSmlDMSilentJob, + silentsession); + + if(r2 == KErrNone) + CApplicationManagementUtility::iSilentSession = silentsession; + + if (!CApplicationManagementUtility::iSilentSession) + { + AppMgmtNotifier* note = new AppMgmtNotifier(m_appName); + if (aInstallSuccess) + { + note->showInstallSuccessNote(); + // Remove temporary files from private directory + const_cast (aCompo).ResetDataL(iInstallRFs); + } + else if(mUserCancelled == 0) + { + note->showInstallFailedNote(); + m_Window->lower(); + } + + delete note; + } + else + { + if (aInstallSuccess) + { + + const_cast (aCompo).ResetDataL(iInstallRFs); + m_Window->lower(); + } + } + + iInstallRFs.Close(); + + iInstallInProgress = EFalse; +#ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_ + iInstaller.Close(); +#endif + RDEBUG("CApplicationManagementServer::InstallCompleteL end"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempJarFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempJarFileNameL(RFs &aFs, + const TDesC& aMetaSource, TFileName &aFileName) const + { + if (aMetaSource != KNullDesC) + { + RFile file; + User::LeaveIfError(file.Open(aFs, aMetaSource, EFileRead)); + CleanupClosePushL(file); + TFileName temp; + temp = ReadJarFileNameL(file); + GenerateTempFileNameL(aFs, temp, aFileName); + CleanupStack::PopAndDestroy(&file); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempFileNameL(const RFs &aFs, + const TDesC& aSource, TFileName &aFileName) const + { + if (aSource != KNullDesC) + { + aFileName.Copy(KInstallDir); + TParse p; + User::LeaveIfError(aFs.Parse(aSource, p)); + aFileName.Append(p.NameAndExt()); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempFileNameL(RFs &aFs, + const CDeploymentComponent& aCompo, TFileName& aSource, + TFileName &aMetaSource, TFileName &aFileName, + TFileName &aMetaFileName) const + { + if (!BaflUtils::FolderExists(aFs, KInstallDir)) + { + aFs.MkDirAll(KInstallDir); + } + + aMetaSource.Copy(aCompo.MetaData().DataFileName()); + GenerateTempFileNameL(aFs, aMetaSource, aMetaFileName); + aSource.Copy(aCompo.Data().DataFileName()); + GenerateTempJarFileNameL(aFs, aMetaSource, aFileName); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempFileNameL(RFs &aFs, + const CDeploymentComponent& aCompo, TFileName &aFileName, + TFileName &aMetaFileName) const + { + TFileName ftemp, msource; + GenerateTempFileNameL(aFs, aCompo, ftemp, msource, aFileName, + aMetaFileName); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ReadJarFileNameL() +// ------------------------------------------------------------------------------------------------ + +TFileName CApplicationManagementServer::ReadJarFileNameL(RFile& aFile) const + { + TFileName jarFileName; + HBufC8* lineBuffer = HBufC8::NewLC(KMaxFileName + 72); // lets hope all lines fit to this + TPtr8 linePtr(lineBuffer->Des()); + TInt length(0); + aFile.Size(length); + HBufC8* data = HBufC8::NewLC(length); + TPtr8 ptr(data->Des()); + aFile.Read(ptr); + RDesReadStream stream(*data); + CleanupClosePushL(stream); + TInt colonIndex = -1; + TInt err(KErrNone); + TInt found(KErrNotFound); + const TInt KJadNameValueSeparator = 0x3A; //':' + + for (;;) + { + TRAP( err, ReadLineL(stream, linePtr) ); + if (err == KErrNone) + { + RDEBUG8_2("Read line: (%S)", &linePtr); + found = linePtr.Find(KMIDletJarURL); + if (found != KErrNotFound && found == 0) // found + { + TPtrC8 filename(linePtr); + colonIndex = linePtr.Locate(KJadNameValueSeparator); + if (colonIndex != KErrNotFound) + { + filename.Set(linePtr.Mid(colonIndex + 1)); // get jar filename, format is: MIDlet-Jar-URL: bomber.jar + jarFileName.Copy(filename); + jarFileName.Trim(); + break; + } + } + } + else + { + User::Leave(err); + } + } + CleanupStack::PopAndDestroy(3, lineBuffer); // stream, data + return jarFileName; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ReadLineL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::ReadLineL(RReadStream& aStream, + TDes8& aLineBuffer) const + { + TBuf8<1> input; + const TUint32 LF = 10; + const TUint32 CR = 13; + TBool endOfLine(EFalse); + TInt errRead(KErrNone); + + // reset + aLineBuffer.Zero(); + + while (!endOfLine) + { + TRAP(errRead, aStream.ReadL(input, 1)); + + if (errRead == KErrEof) + { + // EOF + User::Leave(KErrEof); + } + // check special characters + if (input[0] == LF) + { + // End of line + endOfLine = ETrue; + } + else if (input[0] == CR) + { + // Only end of line if not followed by a LF + } + else + { + // We put any other character in the buffer + if (aLineBuffer.Length() < aLineBuffer.MaxLength()) + { + aLineBuffer.Append(input[0]); + } + } + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::PrepareInstallL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::PrepareInstallL( + const CDeploymentComponent &aComponent, TFileName &aFileName) + { + RDEBUG( "CApplicationManagementServer::PrepareInstallL" ); + TBool res(ETrue); + +#ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_ + TInt err(iInstaller.Connect()); + if (err != KErrNone) + { + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - ERROR leaving cannot connect installer: %d", err ); + User::LeaveIfError(err); + } + CleanupClosePushL(iInstaller); +#endif + + RDEBUG( "CApplicationManagementServer::PrepareInstallL - connected to installer" ); + // Copy data file name (install file) + if (aComponent.Data().DataFileName().Length() > 0) + { + aFileName.Copy(aComponent.Data().DataFileName()); + } + else + { + // data file has not been created for component! + User::Leave(KErrNotFound); + } + // Open RFs session + User::LeaveIfError(iInstallRFs.Connect()); + User::LeaveIfError(iInstallRFs.ShareProtected()); + + // set installoptions and correct mime type + using namespace SwiUI; + iInstallOptions = aComponent.InstallOpts().iOptions; + TInstallReq req; + if (aComponent.Data().MimeType() == SwiUI::KSisMimeType) + { + //convert if MIME type is application/vnd.symbian.install to x-epoc/x-sisx-app + //as installer doesn't support application/vnd.symbian.install MIME type from S60 3rd edition onwards. + req.iMIME = SwiUI::KSisxMimeType; + } + else + { + req.iMIME = aComponent.Data().MimeType(); + } + + if (CDeploymentComponent::IsJavaMimeL(aComponent.MetaData().MimeType())) + { + // Check if both jad and jar files already exist in the phone + if (CDeploymentComponent::IsJavaMimeL(aComponent.Data().MimeType()) + && aComponent.MetaData().MimeType() == SwiUI::KJadMIMEType) + { + // Move both files to temporary location and use jad to install java application + CFileMan *fm = CFileMan::NewL(iInstallRFs); + CleanupStack::PushL(fm); + TFileName source, metasource, metatarget; + aFileName.Copy(KNullDesC8()); // reset + GenerateTempFileNameL(iInstallRFs, aComponent, source, + metasource, aFileName, metatarget); + + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - temp jar file '%S'", &aFileName ); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - temp jad file '%S'", &metatarget ); + + // Copy datafile (jar) + TInt copyer(fm->Copy(source, aFileName)); + + // Copy metadatafile (jad) + TInt copyer2(fm->Copy(metasource, metatarget)); + + CleanupStack::PopAndDestroy(fm); + + RDEBUG_3( "CApplicationManagementServer::PrepareInstallL - (%d)-(%d)", copyer, copyer2 ); + + if (copyer == KErrNone && copyer2 == KErrNone) + { + res = ETrue; + aFileName = metatarget; + req.iMIME = aComponent.MetaData().MimeType(); + } + else + { + User::Leave(KErrWrite); + } + } + else if (aComponent.MetaData().MimeType() == SwiUI::KJadMIMEType) + { + aFileName.Copy(aComponent.MetaData().DataFileName()); + req.iMIME = aComponent.MetaData().MimeType(); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - Using Jad file to install java application: %S", &aFileName ); + } + } + + if (aComponent.GetIAP() > -1) + { + req.iIAP = aComponent.GetIAP(); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL: setting iap to %d", req.iIAP ); + } + else + { + TInt iap = KErrNotFound; + TRAPD( err, SmlHelper::GetDefaultIAPFromDMProfileL( iap ) ); + if (err == KErrNone) + { + req.iIAP = iap; + RDEBUG_2(" -> using DM profile default IAP: %d", iap); + } + else + { + RDEBUG_2("**** ERROR while fetching DM profile default iap: %d", err ); + } + } + + iInstallReq = SwiUI::TInstallReqPckg(req); + RDEBUG8_2( "CApplicationManagementServer::PrepareInstallL: mime type is (%S)", &req.iMIME); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - Using temp file '%S'", &aFileName ); + + User::LeaveIfError(iInstallFile.Open(iInstallRFs, aFileName, EFileRead)); + TInt sz; + User::LeaveIfError(iInstallFile.Size(sz)); + if (!(sz > 0)) + { + res = EFalse; + RDEBUG( "CApplicationManagementServer::PrepareInstallL - ERROR size of source file is 0!" ); + } + +#ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_ + CleanupStack::Pop(&iInstaller); +#endif + + RDEBUG( "CApplicationManagementServer::PrepareInstallL end" ); + + iAppname = aFileName; + + return res; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::InstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::InstallL( + const CDeploymentComponent &aComponent, TRequestStatus &aStatus) + { + RDEBUG( "CApplicationManagementServer::InstallL (async): begin" ); + + if (iInstallInProgress == EFalse) + { + TFileName fn; + TInt type = EInstallWaitDlg; + TInt silentsession = 0; + TInt r2 = RProperty::Get(KPSUidNSmlSOSServerKey, KNSmlDMSilentJob, + silentsession); + + if(r2 == KErrNone) + CApplicationManagementUtility::iSilentSession = silentsession; + + if (!CApplicationManagementUtility::iSilentSession) + { + m_Dlg = new AMWaitProgDialog(m_appName, *this); + m_Dlg->createWaitDialog(type); + if (CApplicationManagementUtility::mHidden == 1) + { + m_Dlg->startIndicator(); + } + else + { + m_Window->raise(); + CApplicationManagementUtility::mCurrDlg->setVisible(true); + } + } + if (PrepareInstallL(aComponent, fn)) + { + if (m_Dlg) + m_Dlg->registerInstallRequest(aStatus); + delete iArgu; + iArgu = NULL; + iArgu = Usif::COpaqueNamedParams::NewL(); + iArgu->AddIntL(Usif::KSifInParam_InstallSilently, 1); + TAMInstallOptions opts = aComponent.InstallOpts(); + TChar drive = opts.iOptions.iDrive; + RFs iFs; + TInt driveNumber; + iFs.CharToDrive(drive,driveNumber); + + iArgu->AddIntL(Usif::KSifInParam_Drive, driveNumber); + + delete iResults; + iResults = NULL; + iResults = Usif::COpaqueNamedParams::NewL(); + + RDEBUG_3( "CApplicationManagementServer::InstallL: Install '%S' sizeof opts: %d", &fn, sizeof (aComponent.InstallOpts())); + TRAPD( err ,iInstaller.Install( iInstallFile, *iArgu, *iResults, aStatus ) ); + + RDEBUG_2( "CApplicationManagementServer::InstallL: status: %d", err); + User::LeaveIfError(err); + iInstallInProgress = ETrue; + } + else + { + RDEBUG( "CApplicationManagementServer::InstallL - PrepareInstallL failed, leaving" ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG( "CApplicationManagementServer::InstallL (async): previous install still in progress...bailing out" ); + TRequestStatus * status = &aStatus; + User::RequestComplete(status, KErrInUse); + } + RDEBUG( "CApplicationManagementServer::InstallL (async): end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::PrepareInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::InstallL( + const CDeploymentComponent &aComponent) + { + RDEBUG( "CApplicationManagementServer::InstallL: begin" ); + + if (iInstallInProgress == EFalse) + { + TFileName fn; + if (PrepareInstallL(aComponent, fn)) + { + iInstallInProgress = ETrue; + RDEBUG_2( "CApplicationManagementServer::InstallL: Install '%S' ", &fn); + SwiUI::TInstallOptionsPckg pkg(aComponent.InstallOpts().iOptions); + iInstallInProgress = EFalse; + } + else + { + RDEBUG( "CApplicationManagementServer::InstallL - PrepareInstallL failed, leaving" ); + User::Leave(KErrArgument); + } + } + RDEBUG( "CApplicationManagementServer::InstallL: end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::UninstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::UninstallL( + const CDeploymentComponent &aComponent, TRequestStatus &aStatus) + { + RDEBUG( "CApplicationManagementServer::UninstallL: begin" ); + if (iInstallInProgress == EFalse) + { + TInt err(iInstaller.Connect()); + User::LeaveIfError(err); + RDEBUG_2( "CApplicationManagementServer::UninstallL: UninstallL '0x%X' ", aComponent.Uid()); + using namespace SwiUI; + iUninstallOptions = aComponent.UninstallOpts(); + + delete iArgu; + iArgu = NULL; + iArgu = Usif::COpaqueNamedParams::NewL(); + iArgu->AddIntL( Usif::KSifInParam_InstallSilently, 1 ); + + delete iResults; + iResults = NULL; + iResults = Usif::COpaqueNamedParams::NewL(); + TRAP( err ,iInstaller.Uninstall( aComponent.GetComponentId(), *iArgu, *iResults, aStatus )); + + RDEBUG_2( "CApplicationManagementServer::UninstallL: UninstallL result '0x%X'", err ); + User::LeaveIfError(err); + iInstallInProgress = ETrue; + } + else + { + RDEBUG( "CApplicationManagementServer::UninstallL: previous uninstall still in progress...bailing out" ); + TRequestStatus * status = &aStatus; + User::RequestComplete(status, KErrInUse); + } + + RDEBUG( "CApplicationManagementServer::UninstallL: end" ); + } +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::PerformRFSL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::PerformRFSL() + { + RDEBUG( "CApplicationManagementServer::PerformRFSL: begin" ); + const RComponentIdArray &arrt = iStorage->GetComponentIds(); + TCertInfoPckg *corcert = NULL; + for (TInt i(0); i < arrt.Count(); i++) + { + RDEBUG_3( "CApplicationManagementServer::PerformRFSL processing dc %d of %d", i, arrt.Count() ); + CDeploymentComponent &c = iStorage->ComponentL(arrt[i]); + + const RCertArray &certs = iStorage->Certificates(); + TInt index = c.Owner(); + TCertInfoPckg *certp = NULL; + if (index >= 0) + { + certp = certs[c.Owner()]; + } + if (!corcert && certp) + { + if (CheckCertL((*certp)())) + { + corcert = certp; + RDEBUG_2( "CApplicationManagementServer::PerformRFSL Found CORP Cert! Removing %d ", i ); + RemoveInternalL(c); + } + else + { + RDEBUG_2( "CApplicationManagementServer::PerformRFSL skipping %d because not corp dc", i ); + } + } + else + { + if (corcert == certp) + { + RDEBUG_2( "CApplicationManagementServer::PerformRFSL Removing %d ", i ); + RemoveInternalL(c); + } + else + { + RDEBUG_2( "CApplicationManagementServer::PerformRFSL skipping %d because not corp dc", i ); + } + } + } + RDEBUG( "CApplicationManagementServer::PerformRFSL: end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::RemoveInternalL() +// ------------------------------------------------------------------------------------------------ + + +void CApplicationManagementServer::RemoveInternalL( + const CDeploymentComponent &aCompo, TBool aDoUninstall /* = ETrue */) + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL - Remove id: (%d)", aCompo.InternalId() ); + TInt err(KErrNone); + TDeploymentComponentName name = aCompo.ComponentName(); + TBuf ne; + ne.Copy(name); + m_appName = QString::fromUtf16(ne.Ptr(), ne.Length()); + + RDEBUG("CApplicationManagementServer: RemoveInternalL - step1"); + + TInt err1 = KErrNone; + if (!err1) + { + RDEBUG("CApplicationManagementServer: RemoveInternalL - step2"); + + aCompo.SetStatusNode(EDelivered_RemoveProgress); + + TDeploymentComponentState st(aCompo.State()); + if (st == EDCSDelivered || st == EDCSDownload) + { + RDEBUG("CApplicationManagementServer: RemoveInternalL - step3 start"); + TRAP(err,iStorage->RemoveL( aCompo.InternalId() )); + RDEBUG("CApplicationManagementServer: RemoveInternalL - step4 start"); + } + else if (st == EDCSActive || st == EDCSInactive) + { + RDEBUG("CApplicationManagementServer: RemoveInternalL - step5 start"); + if (aDoUninstall) + { + if (aCompo.Uid() != TUid::Null()) + { + TInt nonSilentOperation = KErrNotFound; + iOMASCOMOEnabled = IsOMASCOMOEnabledL(); + if (!iOMASCOMOEnabled) + nonSilentOperation = 0; + RDEBUG("CApplicationManagementServer: RemoveInternalL - step5 start 1"); + + TInt silentsession = 0; + RProperty::Get(KPSUidNSmlSOSServerKey, KNSmlDMSilentJob, + silentsession); + + CApplicationManagementUtility::iSilentSession + = silentsession; + TRequestStatus s1 = KRequestPending; + AppMgmtNotifier* note = new AppMgmtNotifier(m_appName); + + // displaying uninstall confirm notes + if (!CApplicationManagementUtility::iSilentSession) + { + CDialogWait* wait = CDialogWait::NewL(); + note->showUninstallDialog(aCompo, wait->iStatus); + m_Window->raise(); + wait->StartWait(); + s1=wait->iStatus; + delete wait; + } + if (s1 != KStatusUserCancelled) + { + TInt type = EUninstallWaitDlg; + TRequestStatus s; + if (!CApplicationManagementUtility::iSilentSession) + { + m_Dlg = new AMWaitProgDialog(m_appName, *this); + m_Dlg->createWaitDialog(type); + m_Window->raise(); + CApplicationManagementUtility::mCurrDlg->setVisible( + true); + + } + CDialogWait* wait1 = CDialogWait::NewL(); + + TRAP(err,UninstallL( aCompo, wait1->iStatus )); + //wait till uninstall completes + wait1->StartWait(); + if (!CApplicationManagementUtility::iSilentSession) + m_Dlg->closeAMWaitDialog(); + m_Window->lower(); + s = wait1->iStatus; + delete wait1; + iInstallInProgress = EFalse; + // Capturing Installer errors,if any + err = s.Int(); + if (s.Int() == KErrNone) + { + note->showUnInstallSuccessNote(); + RDEBUG("CApplicationManagementServer::RemoveInternalL Uninstalled"); + } + else + { + note->showUnInstallFailedNote(); + if (s.Int() == KErrNotFound) + { + RDEBUG( "CApplicationManagementServer: RemoveInternalL WARNING component was not found by uninstaller" ); + } + else + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL ERROR uninstall failed %d", s.Int() ); + } + } + } + else + { + err = SwiUI::KSWInstErrUserCancel; + aCompo.SetStatusNode(EDelivered_RemoveFailed); + RDEBUG( "CApplicationManagementServer: RemoveInternalL User cancelled" ); + } + delete note; + } + else + { + RDEBUG( "CApplicationManagementServer: RemoveInternalL ERROR component is deployed but has null uid - it cannot be uninstalled!" ); + } + } + else + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL - Skipped uninstall of %d", aCompo.InternalId() ); + } + /* + * if (unstall is sucesss) then remove component from storage + * + */ + if (err == KErrNone) + { + iStorage->RemoveL(aCompo.InternalId()); + } + } + else + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL ERROR called with illegal state component id %d", aCompo.State() ); + User::Leave(KErrArgument); + } + /* + * if error set state to remove failed + * Finally call userleaveiferror() + * */ + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_RemoveFailed); + } + } + else + { + err = SwiUI::KSWInstErrUserCancel; + aCompo.SetStatusNode(EDelivered_RemoveFailed); + } + + User::LeaveIfError(err); + } + + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CheckCertL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::CheckCertL(const TCertInfo &aInfo) const + { + TBool go(EFalse); + + if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement)) + { + // #ifdef __SAP_POLICY_MANAGEMENT + RPolicyEngine peng; + + // The management session + // + TInt err(peng.Connect()); + + if (err == KErrNone) + { + CleanupClosePushL(peng); + RPolicyRequest rq; + err = rq.Open(peng); + if (err == KErrNone) + { + CleanupClosePushL(rq); + + TRequestContext rc; + + using namespace PolicyEngineXACML; + using namespace NPolicyConstants; + + rc.AddSubjectAttributeL(KTrustedSubject, aInfo); + rc.AddResourceAttributeL(KResourceId, KApplicationManagement, + KStringDataType); + + TResponse resp; + err = rq.MakeRequest(rc, resp); + if (err == KErrNone) + { + if (resp.GetResponseValue() == EResponsePermit +#ifdef _DEBUG + || resp.GetResponseValue() + == EResponseNotApplicable +#endif + ) + { + go = ETrue; + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; Policy response denies access! %d", resp.GetResponseValue()); + } + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; ERROR making policy request! %d", err); + } + CleanupStack::PopAndDestroy(&rq); + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; ERROR Failed to open policy engine session! %d", err); + } + CleanupStack::PopAndDestroy(&peng); + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; ERROR Failed to connect policy engine! %d", err); + } + User::LeaveIfError(err); + } + else + { + RDEBUG( "CApplicationManagementSession::CheckCertL; No PolicyManagement by featmgr-> cert ok!" ); + go = ETrue; + } + return go; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::HasUidL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::HasUidL(const TUid &aUid, + CDeploymentComponent *& aCompo, CDeploymentComponent *aIgnored /* = NULL */) + { + TBool found(EFalse); + const RComponentIdArray &arrt = iStorage->GetComponentIds(); + TInt count(arrt.Count()); + for (TInt i(0); i < count; i++) + { + CDeploymentComponent &compo = iStorage->ComponentL(arrt[i]); + if (compo.Uid() == aUid) + { + if (&compo != aIgnored) + { + aCompo = &compo; + found = ETrue; + RDEBUG_3( "ApplicationManagementServer: UidExistsL 0x%X - Found NOT ignored %d", aUid.iUid, compo.InternalId() ); + } + else + { + RDEBUG( "ApplicationManagementServer: UidExistsL - Found ignored " ); + } + } + } + if (!found) + { + found = FindInstalledSisUidL(aUid); + if (!found) + { + found = FindInstalledJavaUidL(aUid); + } + } + return found; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FindInstalledSisUidL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::FindInstalledSisUidL(const TUid &aUid) const + { + TBool found(EFalse); + Swi::RSisRegistrySession sisses; + TInt r(sisses.Connect()); + User::LeaveIfError(r); + CleanupClosePushL(sisses); + + RArray uids; + sisses.InstalledUidsL(uids); + CleanupClosePushL(uids); + + TInt uidc(uids.Count()); + for (TInt j(0); found == EFalse && j < uidc; j++) + { + if (uids[j] == aUid) + { + found = ETrue; + } + } + CleanupStack::PopAndDestroy(&uids); + CleanupStack::PopAndDestroy(&sisses); + + return found; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FindInstalledJavaUidL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::FindInstalledJavaUidL(const TUid &aUid) const + { + TBool found(EFalse); + iUtility->RefreshJavaRegistryL(); + found = iUtility->FindInstalledJavaUidL(aUid); + return found; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FindNewUid() +// ------------------------------------------------------------------------------------------------ + +TUid CApplicationManagementServer::FindNewUid(const RArray &aUidsOrig, + const RArray &aUidsNew) const + { + TUid ret(TUid::Null()); + TInt c1(aUidsOrig.Count()); + TInt c2(aUidsNew.Count()); + if (c2 >= c1) + { + for (TInt i(c2 - 1); i >= 0 && !ret.iUid; i--) + { + if (aUidsOrig.Find(aUidsNew[i]) == KErrNotFound) + { + ret = aUidsNew[i]; + } + } + } + return ret; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::JavaUidsL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::JavaUidsL(RArray &aUids) const + { + iUtility->RefreshJavaRegistryL(); + iUtility->JavaUidsL(aUids); + } + +void CApplicationManagementServer::CheckforDuplicateMidletsL( + TMidletParameters& amidletParameters) + { + RDEBUG( "CApplicationManagementServer::CheckforDuplicateMidletsL: Start"); + const RComponentIdArray &arrt = iStorage->GetComponentIds(); + TInt cont(arrt.Count()); + for (TInt i( 0); i < cont; i++) + { + CDeploymentComponent &compo = iStorage->ComponentL(arrt[i]); + if (((compo.State() == EDCSActive) || (compo.State() == EDCSInactive )) + && (compo.MidletName()== amidletParameters.iMidletName) + && (compo.MidletVendor()== amidletParameters.iMidletVenorName)) + { + //remove old one + iStorage->RemoveL(compo.InternalId() ); + } + } + + RDEBUG( "CApplicationManagementServer::CheckforDuplicateMidletsL: End"); + } +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::JavaInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::JavaInstallL(CDeploymentComponent &aCompo) + { + RDEBUG( "CApplicationManagementServer::JavaInstallL: Start"); + + //TRequestStatus s; + TInt err(KErrNone); + // set state to install progressf + CDialogWait* wait = CDialogWait::NewL(); + aCompo.SetStatusNode(EDelivered_InstallProgress); + TRAP(err,InstallL( aCompo,wait->iStatus )); + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(err); + } + wait->StartWait(); + if (!CApplicationManagementUtility::iSilentSession && CApplicationManagementUtility::mCurrDlg) + m_Dlg->closeAMWaitDialog(); + m_Window->lower(); + TRequestStatus s1 = wait->iStatus; + delete wait; + RDEBUG_2( "ApplicationManagementSession: JavaInstallL 1 failed with code %d", + s1.Int() ); + + TInt usifdeplid = -1; + if (iResults && wait->iStatus.Int()!=KErrCancel) + { + iResults->GetIntByNameL(Usif::KSifOutParam_ComponentId, usifdeplid); + RDEBUG_2( "ApplicationManagementSession: JavaInstallL usifdeplid %d", + usifdeplid); + + } + RDEBUG( "wait->StartWait() CApplicationManagementServer::javainstallL Step3"); + + aCompo.SetComponentId(usifdeplid); + + s1 = wait->iStatus; + delete wait; + RDEBUG_2("ApplicationManagementSession: javainstallL with code %d", + s1.Int() ); + if (s1 == KErrCancel) + { + RDEBUG_2( "ApplicationManagementSession: JavaInstallL failed with code %d", + s1.Int() ); + // set state to install failed with data + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(s1.Int()); + } + else + { + TMidletParameters midletParameters; + iUtility->RefreshJavaRegistryL(); + //Ignore if any error comes + TRAPD(err,iUtility->GetInstalledMidletParametersL(midletParameters)); + TRAP(err,CheckforDuplicateMidletsL(midletParameters)); + + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(err); + } + else + { + aCompo.SetStatusNode(EIdle); + } + aCompo.SetUid(midletParameters.iMidletUid); + + RDEBUG( "CApplicationManagementServer::JavaInstallL: Step1"); + if (aCompo.ComponentVersion() == KNullDesC8) + { + aCompo.SetVersionL(midletParameters.bufVersion); + + } + + TBool status = EFalse; + + //Since "C" drive is not removable + + if (midletParameters.iDrive != EDriveC) + { + status = IsInstalledAppRemovableL(midletParameters.iDrive); + } + if (status) + { + RDEBUG( "IsInstalledAppRemovableL(midletParameters.iDrive); True"); + } + else + { + RDEBUG( "IsInstalledAppRemovableL(midletParameters.iDrive); False"); + } + + //check for status drive + aCompo.SetAppRemovableStatus(status); + } + + RDEBUG( "CApplicationManagementServer::JavaInstallL: End"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::SisInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::SisInstallL( + const CDeploymentComponent &aCompo) + { + TRequestStatus s; + CDialogWait* wait = CDialogWait::NewL(); + // set state to install progress + aCompo.SetStatusNode(EDelivered_InstallProgress); + TInt err(KErrNone); + TRAP(err,InstallL( aCompo,wait->iStatus )); + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(err); + } + RDEBUG_2("ApplicationManagementSession: SisInstallL failed with code before startwait %d", + wait->iStatus.Int() ); + wait->StartWait(); + RDEBUG_2("ApplicationManagementSession: SisInstallL failed with code after startwait %d", + wait->iStatus.Int() ); + RDEBUG( "wait->StartWait() CApplicationManagementServer::SisInstallL Step1"); + if (!CApplicationManagementUtility::iSilentSession && CApplicationManagementUtility::mCurrDlg) + m_Dlg->closeAMWaitDialog(); + delete m_Dlg; + m_Dlg=NULL; + RDEBUG( "wait->StartWait() CApplicationManagementServer::SisInstallL Step2"); + + m_Window->lower(); + + TInt usifdeplid = -1; + if (iResults && wait->iStatus.Int()!=KErrCancel) + iResults->GetIntByNameL(Usif::KSifOutParam_ComponentId, usifdeplid); + + RDEBUG( "wait->StartWait() CApplicationManagementServer::SisInstallL Step3"); + + iComp->SetComponentId(usifdeplid); + + TRequestStatus s1 = wait->iStatus; + delete wait; + RDEBUG_2("ApplicationManagementSession: SisInstallL with code %d", + s1.Int() ); + + if(s1 == KErrCancel) + { + s1 = KStatusUserCancelled; + RDEBUG( "KErrCancel visited operation cancelled"); + mUserCancelled=1; + } + if (s1 != KErrNone) + { + RDEBUG_2("ApplicationManagementSession: SisInstallL failed with code %d", + s1.Int() ); + // set state to install failed with data + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(s1.Int()); + } + else + { + // set state to install sucessful + aCompo.SetStatusNode(EIdle); + RDEBUG("ApplicationManagementSession: SisInstallL successfull" ); + } + RDEBUG( "CApplicationManagementServer::SisInstallL: End"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DoTheInstallL() +// ---------------------------------------------------- -------------------------------------------- + +void CApplicationManagementServer::DoTheInstallL(CDeploymentComponent &aCompo) + { + RDEBUG( "CApplicationManagementServer::DoTheInstallL: Start"); + TInt error(KErrNone); + iComp = &aCompo; + + TDeploymentComponentName name = aCompo.ComponentName(); + if(name.Compare(KNullDesC8())==0) + { + name = aCompo.UserId(); + } + TBuf nameBuf; + nameBuf.Copy(name); + m_appName = QString::fromUtf16(nameBuf.Ptr(), nameBuf.Length()); + + TRequestStatus stat = KErrCompletion; + if (!aCompo.DriveSelected() + && !CApplicationManagementUtility::iSilentSession) + { + // displaying install confirm notes + CDialogWait* ao = CDialogWait::NewL(); + AppMgmtNotifier* note = new AppMgmtNotifier(); + int err = KErrNone; + TRAP( err, QT_TRYCATCH_LEAVING(note->showInstallDialog(iComp, ao->iStatus))); + ao->StartWait(); + stat = ao->iStatus; + delete ao; + m_Window->lower(); + delete note; + } + aCompo.SetDriveSelectionStatus(false); + if (stat == KErrCompletion) + { + if (CDeploymentComponent::IsJavaMimeL(aCompo.Data().MimeType()) + || CDeploymentComponent::IsJavaMimeL( + aCompo.MetaData().MimeType())) + { + TRAP( error, JavaInstallL( aCompo ) ); + } + else + { + TRAP( error, SisInstallL( aCompo ) ); + if(error==KErrNone) + { + SetSisAppVersionAndDriveL(aCompo); + } + } + + + + if (error == KErrNone) + { + InstallCompleteL(aCompo, ETrue); + CDeploymentComponent *old = DoDataUpdateCheckL(aCompo); + if (old) + { + if (aCompo.State() == EDCSDelivered) + { + if (old->State() == EDCSActive || old->State() + == EDCSInactive) + { + RDEBUG("AMSession: DoTheInstallL ** deleting old node **" ); + iStorage->RemoveL(old->InternalId()); + } + } + } + iStorage->InstalledL(aCompo); + } + else + { + InstallCompleteL(aCompo, EFalse); + User::Leave(error); + } + } + else + { + aCompo.SetStatusNode(EDelivered_InstallFailedwithOutData); + } + + RDEBUG( "CApplicationManagementServer::DoTheInstallL: End"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DoDataUpdateCheckL() +// ------------------------------------------------------------------------------------------------ + +CDeploymentComponent *CApplicationManagementServer::DoDataUpdateCheckL( + CDeploymentComponent &aCompo) + { + CDeploymentComponent *old = NULL; + if (aCompo.Uid() != TUid::Null() && HasUidL(aCompo.Uid(), old, &aCompo)) + { + // check for Uid component.. Legacy code removed. + } + return old; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::SetDataL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::SetDataL(CDeploymentComponent &aCompo, + const TDesC8 &aData, const TDesC8 &aMime) + { + aCompo.SetDataL(aData, aMime); + DoDataUpdateCheckL(aCompo); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FullUpdateL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::FullUpdateL(const TUint32 sid, + const TUint32 tid) + { + CDeploymentComponent &scompo = iStorage->ComponentL(sid); + CDeploymentComponent &tcompo = iStorage->ComponentL(tid); + FullUpdateL(scompo, tcompo); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FullUpdateL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::FullUpdateL(CDeploymentComponent &scompo, + const CDeploymentComponent &tcompo) + { + if (scompo.State() == EDCSDelivered) + { + if (tcompo.State() == EDCSActive || tcompo.State() == EDCSInactive) + { + TRequestStatus s2; + InstallL(scompo, s2); + User::WaitForRequest(s2); + if (s2 != KErrNone) + { + RDEBUG_2( "ApplicationManagementSession: FullUpdateL failed with code %d", s2.Int() ); + User::Leave(s2.Int()); + } + else + { + InstallCompleteL(scompo); + // Before deleting old node ,copy node values which are not set in new node from old node + if (scompo.ComponentId() == KNullDesC8) + scompo.SetIdL(tcompo.ComponentId()); + + if (scompo.ComponentName() == KNullDesC8) + scompo.SetNameL(tcompo.ComponentName()); + + if (scompo.ComponentVersion() == KNullDesC8) + scompo.SetVersionL(tcompo.ComponentVersion()); + + //Tag tcompo state for deletion. Cant delete now, since nsmldmtree woudnt be updated + //Remove the const'ness since state needs to be updated. + + iStorage->SetDeploymentComponentState( + const_cast (tcompo), + EDCSDelete); + + iStorage->InstalledL(scompo); + RDEBUG( "ApplicationManagementSession: FullUpdateL ok" ); + } + } + else + { + RDEBUG_2( "ApplicationManagementSession: ERROR FullUpdateL called for illegal state component: %d!", scompo.State() ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG( "ApplicationManagementSession: ERROR FullUpdateL called for illegal state message!" ); + User::Leave(KErrArgument); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::IsDataFileB64EncodedL() +// ------------------------------------------------------------------------------------------------------------------- +TBool CApplicationManagementServer::IsDataFileB64EncodedL(RFile &aFile, + TInt& aLength) + { + RDEBUG("CApplicationManagementServer::IsDataFileB64EncodedL() : start"); + TBool encoded = ETrue; // assume b64 encoded + TInt bufSize(KBase64BufSize); + TInt offset(0); + HBufC8 *dataBuf = HBufC8::NewLC(bufSize); + TPtr8 dataPtr = dataBuf->Des(); + aFile.Size(aLength); + aFile.Seek(ESeekStart, offset); + + while (encoded) + { + aFile.Read(dataPtr); + if (!dataPtr.Length()) + { + break; + } + offset = 0; + aFile.Seek(ESeekCurrent, offset); + RDEBUG_2("OFFSET: %d", offset); + encoded = CheckB64Encode(dataPtr); + } + RDEBUG_2("Encoded: %d", encoded); + CleanupStack::PopAndDestroy(dataBuf); + offset = 0; + aFile.Seek(ESeekStart, offset); + + RDEBUG("CApplicationManagementServer::IsDataFileB64EncodedL() : end"); + return encoded; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::CheckB64Encode( const TDesC8& aData ) +// ------------------------------------------------------------------------------------------------------------------- +TBool CApplicationManagementServer::CheckB64Encode(const TDesC8& aData) + { + TInt inputIndex = 0; + TInt inputLen = aData.Length(); + + while (inputIndex < inputLen) + { + const TUint8& p = aData[inputIndex]; + + if ((p >= 48 && p <= 57) || (p >= 65 && p <= 90) || (p >= 97 && p + <= 122) || p == 43 || p == 47 || p == 61 || p == 10 || p + == 13) + { + } + else + { + return EFalse; + } + + inputIndex++; + + } + + return ETrue; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GetAMServerDownloadDBL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GetAMServerDownloadDBL(TUint32 internalid, + TInt& finalresult, TDes8& aTargetURI) + { + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step1" ); + + TBuf<50> internalidbuf; + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step2" ); + internalidbuf.Num(internalid); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step3" ); + + RPointerArray aItemArray; + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step4" ); + + iAMServerDB->GetEntryForLUIDL(aItemArray, internalidbuf); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step5" ); + + if (aItemArray.Count() != 0) + { + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step6" ); + + finalresult = aItemArray[0]->iResult; + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step7" ); + + if (finalresult < KErrNone) + User::Leave(KErrGeneral); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step8" ); + + if (*aItemArray[0]->iTargetURI == KNullDesC8()) + User::Leave(KErrGeneral); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step9" ); + aTargetURI.Copy(*aItemArray[0]->iTargetURI); + + } + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step10" ); + aItemArray.ResetAndDestroy(); + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DeleteGenericAlertForIDL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DeleteGenericAlertForIDL( + TUint32 internalid) + { + iAMServerDB->DeleteFromDatabaseL(internalid); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::DecodeB64DataFileL( RFile& aDataFile, RFile& aDestinationFile ) +// ------------------------------------------------------------------------------------------------------------------- +void CApplicationManagementServer::DecodeB64DataFileL(RFile& aSourceFile, + RFile& aDestinationFile) + { + RDEBUG( "CApplicationManagementServer::DecodeB64DataFileL(): Start" ); + // Create buffers + //TInt b64bufferSize = 131072; + TInt decodedBufferSize = ((KBase64BufSize * 3) / 4 + 16); + HBufC8 *dataBuf = HBufC8::NewLC(KBase64BufSize); + TPtr8 dataPtr = dataBuf->Des(); + HBufC8* targetBuf = HBufC8::NewLC(decodedBufferSize); + TPtr8 targetPtr(targetBuf->Des()); + + TInt offset(0); + TInt length(0); + TBool reading(ETrue); + aSourceFile.Size(length); + RDEBUG_2( "CApplicationManagementServer::DecodeB64DataFileL(): b64 file total size: (%d)", length ); + aSourceFile.Seek(ESeekStart, offset); + + // Initialize decoder + TImCodecB64 B64Coder; + B64Coder.Initialise(); + + while (reading) + { + aSourceFile.Read(dataPtr); + if (!dataPtr.Length()) + { + // EOF + break; + } + offset = 0; + aSourceFile.Seek(ESeekCurrent, offset); + RDEBUG_2("OFFSET: %d", offset); + + // decode data + B64Coder.Decode(dataPtr, targetPtr); + // write decoded data to temporary file + aDestinationFile.Write(targetPtr); + } + CleanupStack::PopAndDestroy(targetBuf); + CleanupStack::PopAndDestroy(dataBuf); + + offset = 0; + aDestinationFile.Seek(ESeekStart, offset); + RDEBUG( "CApplicationManagementServer::DecodeB64DataFileL(): end" ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::DecodeB64DataLC( const TDesC8& aData ) +// ------------------------------------------------------------------------------------------------------------------- +HBufC8* CApplicationManagementServer::DecodeB64DataLC(const TDesC8 &aData) + { + RDEBUG( "CApplicationManagementServer::DecodeB64DataLC(): Start" ); + TImCodecB64 B64Coder; + B64Coder.Initialise(); + HBufC8 *target = HBufC8::NewLC((aData.Length() * 3) / 4 + 16); + TPtr8 targetPtr(target->Des()); + B64Coder.Decode(aData, targetPtr); + RDEBUG( "CApplicationManagementServer::DecodeB64DataLC(): End" ); + return target; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::EncodeDataL( const TDesC8& aData, CBufBase &aTarget ) +// ------------------------------------------------------------------------------------------------------------------- +void CApplicationManagementServer::EncodeDataL(const TDesC8& aData, + CBufBase &aTarget) + { + TInt outLen(aData.Length() * 2); + aTarget.ExpandL(0, outLen); + TImCodecB64 B64Coder; + B64Coder.Initialise(); + TPtr8 target(aTarget.Ptr(0)); + TInt decoded(B64Coder.Encode(aData, target)); + TInt s(target.Length()); + aTarget.ResizeL(s); + aTarget.Compress(); + if (!decoded) + { + RDEBUG( "CApplicationManagementServer::EncodeDataL(): Encoding b64 failed?" ); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::CApplicationManagementSession +// ------------------------------------------------------------------------------------------------------------------- +inline CApplicationManagementSession::CApplicationManagementSession() + { + RDEBUG_2( "CApplicationManagementSession::CApplicationManagementSession 0x%x", this); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::CApplicationManagementSession +// ------------------------------------------------------------------------------------------------------------------- + +inline CApplicationManagementSession::CApplicationManagementSession( + const TCertInfo &aInfo) : + iCertInfo(aInfo) + { + RDEBUG( "CApplicationManagementSession::CApplicationManagementSession (cert) " ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::Server() +// ------------------------------------------------------------------------------------------------------------------- + +inline CApplicationManagementServer& CApplicationManagementSession::Server() const + { + return *static_cast (const_cast (CSession2::Server())); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::CreateL() +// ------------------------------------------------------------------------------------------------------------------- +// 2nd phase construct for sessions - called by the CServer framework + +void CApplicationManagementSession::CreateL() + { + RDEBUG_2( "ApplicationManagementSession: CApplicationManagementSession::CreateL: 0x%x", this ); + + Server().AddSession(); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::~CApplicationManagementSession() +// ------------------------------------------------------------------------------------------------------------------- + +CApplicationManagementSession::~CApplicationManagementSession() + { + RDEBUG_3("CApplicationManagementSession::~CApplicationManagementSession 0x%X - 0x%X", reinterpret_cast(this), + reinterpret_cast(this)+sizeof( CApplicationManagementSession ) ); + RDEBUG_2("CApplicationManagementSession::~CApplicationManagementSession iCertInfo offs 0x%X", + reinterpret_cast(&this->iCertInfo) - reinterpret_cast(this) ); + + Server().DropSession(); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ServiceL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ServiceL(const RMessage2& aMessage) + { + if (aMessage.Function() == EPerformRfs) + { + TRAPD( err, Server().PerformRFSL() ); + aMessage.Complete(err); + } + else + { + TBool handled(EFalse); + TInt err(KErrNone); + TRAP( err, handled = PreDispatchMessageL( aMessage ) ); + if (!handled) + { + TRAP(err,DispatchMessageL(aMessage)); + } + + // Some of the functions contains operations that already complete message + // doing Complete() twice will cause panic + if (aMessage.Handle()) + { + aMessage.Complete(err); + } + } + } + +// CApplicationManagementSession::PreDispatchMessageL() +// ------------------------------------------------------------------------------------------------------------------- + +TBool CApplicationManagementSession::PreDispatchMessageL( + const RMessage2 &aMessage) + { + TBool ret(EFalse); + // These succeed regardless of certificate.... + switch (aMessage.Function()) + { + case EGetStateChangingIdsCountOperation: + { + // gets count of items list of ids that are potentially changing state + StateChangeComponentIdsCountL(aMessage); + ret = ETrue; + break; + } + case EGetStateChangingIdsOperation: + { + // gets list of ids that are potentially changing state + StateChangeComponentIdsL(aMessage); + ret = ETrue; + break; + } + case ECompleteStateChangeOperation: // completes change of state + { + StateChangeCompleteL(aMessage); + ret = ETrue; + break; + } + default: + { + break; + } + } + return ret; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DispatchMessageL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DispatchMessageL( + const RMessage2& aMessage) + { + RDEBUG_2( "CApplicationManagementSession::DispatchMessageL; %d" , + aMessage.Function() ); + + TBool go(EFalse); + if (iTrustAdded) + { + go = Server().CheckCertL(iCertInfo); + } + else + { + go = ETrue; + } + + if (go) + { + switch (aMessage.Function()) + { + case EAddTrust: + { + RDEBUG_2( "CApplicationManagementSession::DispatchMessageL; EAddTrust this=0x%x", this ); + AddTrustL(aMessage); + break; + } + case EDeplCompCountOperation: + { + ComponentCountL(aMessage); + return; + } + case EDeplCompIdsOperation: + { + ComponentIdsL(aMessage); + return; + } + case EDeplCompDeliverCompleteOperation: + { + DeliverCompleteL(aMessage); + break; + } + case EDeplCompGetOperation: + { + GetComponentL(aMessage); + break; + } + case EInstallOperation: + { + InstallL(aMessage); + break; + } + case EDeplCompAttrUpdateOperation: + { + UpdateL(aMessage); + break; + } + case EDeplCompGetDataOperation: + { + GetDataL(aMessage); + break; + } + case EDeplCompGetDataLengthOperation: + { + GetDataLengthL(aMessage); + break; + } + case EDeplCompRemoveOperation: + { + RemoveL(aMessage); + break; + } + case EDeplCompDeliverStartOperation2: + { + Deliver2L(aMessage); + break; + } + case EDeplCompUpdateDataOperation: + { + UpdateDataL(aMessage); + break; + } + case EDeplCompUpdateStreamedDataOperation: + { + UpdateStreamedDataL(aMessage); + break; + } + case EDeplCompDownloadOperation: + { + DownloadL(aMessage); + break; + } + case EDeplCompUpdateOperation: + { + FullUpdateL(aMessage); + break; + } + case EDeplCompGetUserIdOperation: + { + GetUserIdL(aMessage); + break; + } + case EDeplCompStartDownloadOperation: + { + StartDownloadL(aMessage); + break; + } + case EDeplCompDeactivateOperation: + { + DeactivateL(aMessage); + break; + } + case EDeplCompActivateOperation: + { + ActivateL(aMessage); + break; + } + case EDeplCompGetTemporaryInstFile: + { + GetTemporaryInstFileL(aMessage); + break; + } + + case EDeplCompGetFinalResultForGA: + { + GetFinalResultForGAL(aMessage); + break; + + } + case EDeplCompGenericAlertSent: + { + GenericAlertSentForIdL(aMessage); + break; + } + case ECheckStatusNodes: + { + CheckStatusNodesValuesL(); + break; + } + + default: + { + User::Leave(KErrNotSupported); + break; + } + } + } + else + { + RDEBUG_2( "CApplicationManagementSession::DispatchMessageL; Policy prevented action this=0x%x", this ); + User::Leave(KErrAccessDenied); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GenericAlertSentForIdL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GenericAlertSentForIdL( + const RMessage2& aMessage) const + { + TUint32 luid; + TPckg pk(luid); + TInt read(aMessage.Read(0, pk)); + + Server().DeleteGenericAlertForIDL(luid); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetFinalResultForGAL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetFinalResultForGAL( + const RMessage2& aMessage) + { + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 1" ); + TUint32 luid; + TPckg pk(luid); + + TInt finalresult = KErrNone; + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 2" ); + + HBufC8 *targetURI = HBufC8::NewL(512); + TPtr8 ptr = targetURI->Des(); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 3" ); + + TInt read(aMessage.Read(0, pk)); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 4" ); + + Server().GetAMServerDownloadDBL(luid, finalresult, ptr); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 5" ); + + RDEBUG_2( "ApplicationManagementServer: GetFinalResultForGAL Count is %d", finalresult ); + TPckg p1(finalresult); + aMessage.WriteL(1, p1); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 6" ); + aMessage.WriteL(2, ptr); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 7" ); + if (targetURI) + delete targetURI; + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ComponentCountL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ComponentCountL(const RMessage2& aMessage) + { + RDEBUG( "CApplicationManagementSession: ComponentCountL" ); + TDeploymentComponentState st; + TPckg pk(st); + + TInt read(aMessage.Read(1, pk)); + RDEBUG_3( "CApplicationManagementSession: ComponentCountL State is %d, read %d", st, read); + + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + RComponentIdArray arr; + CleanupClosePushL(arr); + if ((st == EDCSActive) || (st == EDCSInactive)) + { + ActiveComponentsL(arrt, arr, st); + } + else + { + TInt count(arrt.Count()); + for (TInt i(0); i < count; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL( + arrt[i]); + if (st == EDCSNone || compo.State() == st) + { + arr.Append(arrt[i]); + } + } + } + TInt n(arr.Count()); + CleanupStack::PopAndDestroy(&arr); + + RDEBUG_2( "ApplicationManagementServer: ComponentCountL Count is %d", n ); + TPckg p(n); + + aMessage.WriteL(0, p); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ActiveComponentsL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ActiveComponentsL( + const RComponentIdArray &aArrt, RComponentIdArray &aArr, + TDeploymentComponentState &aState) const + { + Swi::RSisRegistrySession sisses; + TInt r(sisses.Connect()); + User::LeaveIfError(r); + CleanupClosePushL(sisses); + + RArray uids; + sisses.InstalledUidsL(uids); + CleanupClosePushL(uids); + TInt cont(aArrt.Count()); + TInt uidc(uids.Count()); + RArray juids; + Server().JavaUidsL(juids); + CleanupClosePushL(juids); + TInt juidc(juids.Count()); + RComponentIdArray rem; + CleanupClosePushL(rem); + for (TInt i(0); i < cont; i++) + { + CDeploymentComponent &compo = + Server().Storage()->ComponentL(aArrt[i]); + TDeploymentComponentState state = compo.State(); + if (state == aState) + { + TBool add(EFalse); + const TUid &uid(compo.Uid()); + for (TInt j(0); add == EFalse && j < uidc; j++) + { + + if (uids[j] == uid) + { + RDEBUG( "CApplicationManagementSession::ActiveComponentsL Entered" ); + + // Check if this registry entry is present + Swi::RSisRegistrySession sisSession; + User::LeaveIfError(sisSession.Connect()); + CleanupClosePushL(sisSession); + + Swi::RSisRegistryEntry sisEntry; + + //Opens the base package entry by specifying a UID. + User::LeaveIfError(sisEntry.Open(sisSession, compo.Uid())); + CleanupClosePushL(sisEntry); + + add = sisEntry.IsPresentL(); + + if (add) + { + // If Present update the Version, name and other info to that deployement component. Since application would have got an update + // by some other means + TVersion version = sisEntry.VersionL(); + TBuf8 pkgDes; + pkgDes.AppendNum(version.iMajor); + pkgDes.Append(KLiteralPeriod); + pkgDes.AppendNum(version.iMinor); + + HBufC *packagename = sisEntry.PackageNameL(); + TBuf8<512> packagename8; + packagename8.Copy(*packagename); + delete packagename; + + compo.SetNameL(packagename8); + compo.SetVersionL(pkgDes); + + Server().Storage()->UpdateL(compo); + + RDEBUG( "CApplicationManagementSession::ActiveComponentsL ETrue" ); + + } + else + RDEBUG( "CApplicationManagementSession::ActiveComponentsL EFalse" ); + CleanupStack::PopAndDestroy(2, &sisSession); + } + } + if (!add) // go throug java suites + { + for (TInt k(0); add == EFalse && k < juidc; k++) + { + if (juids[k] == uid) + { + add = ETrue; + } + } + } + if (add) + { + aArr.Append(aArrt[i]); + } + else + { + RDEBUG8_3( "ApplicationManagementServer: ActiveComponentCountL skipping 0x%x, %S", + compo.Uid() ,&compo.ComponentId() ); + rem.Append(aArrt[i]); + } + } + } + TInt rc(rem.Count()); + for (TInt t(0); t < rc; t++) + { + RDEBUG_2( "ApplicationManagementServer: ActiveComponentCountL removing non existing %d", rem[t] ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(rem[t]); + if (!compo.AppRemovable()) + Server().RemoveInternalL(compo, EFalse); + } + CleanupStack::PopAndDestroy(&rem); + CleanupStack::PopAndDestroy(&juids); + CleanupStack::PopAndDestroy(&uids); + CleanupStack::PopAndDestroy(&sisses); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ComponentIdsL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ComponentIdsL(const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: ComponentIdsL" ); + TDeploymentComponentState st; + TPckg pk(st); + + TInt read(aMessage.Read(1, pk)); + RDEBUG_3( "CApplicationManagementSession: ComponentIdsL State is %d, read %d", st, read); + + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + TInt buflen(0); + TUint32* buf = NULL; + if (st == EDCSNone) + { + buflen = arrt.Count(); + buf = new (ELeave) TUint32[buflen]; + CleanupArrayDeletePushL(buf); + for (TInt i(0); i < buflen; i++) + { + RDEBUG_2("ApplicationManagementSession: ComponentIdsL Adding %d!!", arrt[i]); + buf[i] = arrt[i]; + } + } + else + { + RComponentIdArray arr; + if (st == EDCSActive) + { + ActiveComponentsL(arrt, arr, st); + } + else + { + TInt artc(arrt.Count()); + for (TInt i(0); i < artc; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL( + arrt[i]); + if (compo.State() == st) + { + arr.Append(arrt[i]); + } + } + } + buflen = arr.Count(); + buf = new (ELeave) TUint32[buflen]; + CleanupArrayDeletePushL(buf); + + TUint32 len(aMessage.GetDesMaxLength(0) / 4); + if (buflen == len) + { + RDEBUG( "CApplicationManagementSession: ComponentIdsL Right count!!" ); + } + else + { + RDEBUG_3( "CApplicationManagementSession: ComponentIdsL Wrong count (is %d, should be %d)!!", len, buflen); + if (len < buflen) + { + buflen = len; + } + } + for (TInt i(0); i < buflen; i++) + { + RDEBUG_2( "CApplicationManagementSession: ComponentIdsL Adding %d!!", + arr[i] ); + buf[i] = arr[i]; + } + arr.Close(); + } + + TPtrC8 p((TUint8*) buf, buflen * sizeof(TUint32)); + aMessage.WriteL(0, p); + + CleanupStack::PopAndDestroy(buf); + } + +#ifdef _DEBUG +HBufC* Des8to16LC(const TDesC8 &aDes) + { + HBufC *b = HBufC::NewLC(aDes.Length()); + TPtr p(b->Des()); + p.Copy(aDes); + return b; + } + +HBufC* ToStringLC(TDeploymentComponent &aComp) + { + HBufC *b = HBufC::NewLC(aComp.iId.Length() + aComp.iName.Length() + + aComp.iVersion.Length() + 10 + 50); + TPtr p(b->Des()); + _LIT( KFormat, "Id: '%S', Name: '%S', Version: '%S', State: %d, OldState: %d"); + p.Format(KFormat, &*Des8to16LC(aComp.iId), &*Des8to16LC(aComp.iName), + &*Des8to16LC(aComp.iVersion), aComp.iState, aComp.iOldState); + CleanupStack::PopAndDestroy(3); + return b; + } +#endif + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::Deliver2L() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::Deliver2L(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: Deliver2L" ); + + TDeploymentComponentIPC comp; + TPckg pcomp(comp); + TInt read2(aMessage.Read(0, pcomp)); + + HBufC8 *data = HBufC8::NewLC(aMessage.GetDesLength(1)); + TPtr8 pbuf(data->Des()); + TInt read(aMessage.Read(1, pbuf)); + + CDeploymentComponent *compo = NULL; + if (iTrustAdded) + { + compo = Server().Storage()->NewComponentL(EDCSDelivered, + comp.iUserId, &iCertInfo); + } + else + { + compo + = Server().Storage()->NewComponentL(EDCSDelivered, + comp.iUserId); + } + + compo->Set(comp.iComponent); + compo->Data().SetDataL(pbuf, comp.iMimeType); + Server().Storage()->UpdateL(*compo); + compo->CopyStateTo(comp.iComponent); + +#ifdef _DEBUG + RDEBUG_2( "Deliver2L: TDeploymentComponent is '%S'", + ToStringLC( comp.iComponent ) ); + CleanupStack::PopAndDestroy(); +#endif + + TPckg pcomp2(comp.iComponent); + aMessage.Write(0, pcomp2); + CleanupStack::PopAndDestroy(data); + TInt n(compo->InternalId()); + TPckg p(n); + aMessage.WriteL(2, p); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DeliverCompleteL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DeliverCompleteL( + const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: DeliverCompleteL" ); + TUint32 id; + TPckg pid(id); + + TInt read(aMessage.Read(0, pid)); + RDEBUG_2( "ApplicationManagementSession: DeliverCompleteL id is %d", id ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + HBufC8 *opts = HBufC8::NewLC(aMessage.GetDesLength(1)); + TPtr8 popts(opts->Des()); + TInt read1(aMessage.Read(1, popts)); + compo.SetInstallOptsL(*opts); + + HBufC8 *meta = HBufC8::NewLC(aMessage.GetDesLength(2)); + TPtr8 pmeta(meta->Des()); + TInt read2(aMessage.Read(2, pmeta)); + compo.SetMetaDataL(*meta, KNullDesC8); + + CleanupStack::PopAndDestroy(meta); + CleanupStack::PopAndDestroy(opts); + Server().Storage()->UpdateL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetComponentL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetComponentL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetComponentL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + RDEBUG_2( "ApplicationManagementSession: GetComponentL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + TDeploymentComponent comp; + compo.CopyStateTo(comp); + + TPckg pcomp(comp); + aMessage.Write(1, pcomp); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StartDownloadL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StartDownloadL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: StartDownloadL" ); + TUint32 id = 0; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + TPckgBuf target; + read = aMessage.Read(1, target); + RDEBUG_2( "ApplicationManagementSession: StartDownloadL id is %d", id ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + compo.SetDownloadTarget(target()); + Server().AddDownloadL(&compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DeactivateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DeactivateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: DeactivateL" ); + TUint32 id = 0; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + RDEBUG_2( "ApplicationManagementSession: DeactivateL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + Server().Storage()->DeactivateL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ActivateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ActivateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: ActivateL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + RDEBUG_2( "ApplicationManagementSession: ActivateL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + Server().Storage()->ActivateL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetUserIdL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetUserIdL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetUserIdL" ); + TUint32 id = 0; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + RDEBUG_2( "ApplicationManagementSession: GetUserIdL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + aMessage.Write(1, compo.UserId()); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetTemporaryInstFileL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetTemporaryInstFileL( + const RMessage2& aMessage) const + { + // TIpcArgs( &id, &itemid, &filehandle ) + RDEBUG( "ApplicationManagementSession: GetTemporaryInstFileL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + TDeplCompAttrType item; + TPckg itemid(item); + read = aMessage.Read(1, itemid); + + RDEBUG_2( "ApplicationManagementSession: GetTemporaryInstFileL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + TFileName fileName; + + if (item == EDCData) + { + fileName.Copy(compo.Data().DataFileName()); + } + else if (item == EDCMetaData) + { + fileName.Copy(compo.MetaData().DataFileName()); + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetTemporaryInstFileL: Not supported type: (%d)", item); + User::Leave(KErrNotSupported); + } + + RDEBUG_2( "ApplicationManagementSession: GetTemporaryInstFileL: (%S)", &fileName); + + RFs fs; + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(fs.ShareProtected()); + CleanupClosePushL(fs); + RFile file; + User::LeaveIfError(file.Open(fs, fileName, EFileWrite)); + CleanupClosePushL(file); + + // Takes care of completing with session (RFs), + // SendReceieve returns session handle at client side + User::LeaveIfError(file.TransferToClient(aMessage, 2)); + CleanupStack::PopAndDestroy(2, &fs); // fs , file + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::PackageSizeL() +// ------------------------------------------------------------------------------------------------------------------- + +TInt CApplicationManagementSession::PackageSizeL( + Swi::RSisRegistrySession& aSession, Swi::RSisRegistryEntry& aEntry) + { + RPointerArray listPackages; + TInt size(0); + TInt err(0); + CleanupClosePushL(listPackages); + + aEntry.AugmentationsL(listPackages); + + for (TInt index(0); index < listPackages.Count(); index++) + { + TRAP(err, AugmentationSizeL( aSession, *listPackages[index])) + if (err != KErrNone) + { + break; + } + } + + if (err != KErrNone) + { + size = 0; + } + else + { + TRAP(err, size += aEntry.SizeL() ); + } + + listPackages.ResetAndDestroy(); + CleanupStack::PopAndDestroy(&listPackages); + + if (err != KErrNone) + { + //We leave if there was an error, + // but we have to clean up the listPackages before the leave. + User::Leave(err); + } + + return size; + } + +// ------------------------------------------------------------------------------------------------ +// CAppMngrSisxInfo::AugmentationSizeL() +// Returns the Size of the package +// (other items were commented in a header). +// ------------------------------------------------------------------------------------------------ +// +TInt CApplicationManagementSession::AugmentationSizeL( + Swi::RSisRegistrySession& aSession, + const Swi::CSisRegistryPackage& aPackage) + { + TInt size(0); + Swi::RSisRegistryEntry regEntry; + CleanupClosePushL(regEntry); + + regEntry.OpenL(aSession, aPackage); + size += PackageSizeL(aSession, regEntry); + + CleanupStack::PopAndDestroy(®Entry); + + return size; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::LookupSisRegistryL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::LookupSisRegistryL() + { + Swi::RSisRegistrySession sisses; + TInt r(sisses.Connect()); + RPointerArray pkgs(12); + sisses.InstalledPackagesL(pkgs); + + TInt count(pkgs.Count()); + for (TInt i(0); i < count; i++) + { + Swi::CSisRegistryPackage* p = pkgs[i]; + + RDEBUG_5(" Found package: %d, '%S', uid: 0x%X, size: %d" , + i, &p->Name(), p->Uid().iUid, AugmentationSizeL( sisses, *p ) ); + } + + sisses.Close(); + pkgs.ResetAndDestroy(); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::InstallL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::InstallL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: InstallL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + + TDeploymentComponentState targetst; + TPckg pk(targetst); + + read = aMessage.Read(1, pk); + + RDEBUG_3( "ApplicationManagementSession: InstallL id is %d, targetstate %d", + id, targetst ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + if (compo.State() == EDCSDelivered) + { + Server().DoTheInstallL(compo); + } + else + { + User::Leave(KErrArgument); + } + RDEBUG_2( "ApplicationManagementSession: InstallL success. New compo state (%d)", compo.State()); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::UpdateDataL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::UpdateDataL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: UpdateDataL" ); + + TDeplCompDataIPC ipc; + TPckg pipc(ipc); + TInt read(aMessage.Read(0, pipc)); + RDEBUG_2( "ApplicationManagementSession: UpdateDataL id is %d", ipc.iInternalId ); + + HBufC8 *buf = HBufC8::NewLC(aMessage.GetDesLength(1)); + TPtr8 pbuf(buf->Des()); + TInt read2(aMessage.Read(1, pbuf)); + + CDeploymentComponent &compo = Server().Storage()->ComponentL( + ipc.iInternalId); + + if (Server().CheckB64Encode(pbuf)) + { + RDEBUG( "ApplicationManagementSession: UpdateDataL data is base64 encoded"); + // b64 encoded data, decode it + HBufC8* tmp; + tmp = Server().DecodeB64DataLC(pbuf); + pbuf.Copy(*tmp); + pbuf = buf->Des(); + CleanupStack::PopAndDestroy(tmp); + } + + if (compo.State() == EDCSDelivered) + { + if (ipc.iAttrType == EDCData) + { + compo.SetDataL(pbuf, ipc.iDataMime); + } + else if (ipc.iAttrType == EDCMetaData) + { + compo.SetMetaDataL(pbuf, ipc.iDataMime); + } + else + { + RDEBUG_2( "ApplicationManagementSession::UpdateDataL - ERROR UpdateDataL called for illegal item: %d!", ipc.iAttrType ); + User::Leave(KErrArgument); + } + + Server().Storage()->UpdateL(compo); + } + else + { + RDEBUG( "ApplicationManagementSession::UpdateDataL - ERROR UpdateDataL called for illegal state message!" ); + User::Leave(KErrArgument); + } + CleanupStack::PopAndDestroy(buf); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::UpdateStreamedDataL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::UpdateStreamedDataL( + const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: UpdateStreamedDataL() Start"); + TDeplCompDataIPC ipc; + TPckg pipc(ipc); + TInt read(aMessage.Read(0, pipc)); + RDEBUG_2( "ApplicationManagementSession: UpdateStreamedDataL id is %d", ipc.iInternalId ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL( + ipc.iInternalId); + + if (compo.State() == EDCSDelivered) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + RFile file; + TFileName dataFileName; + TInt length(0); + + if (ipc.iAttrType == EDCData) + { + dataFileName.Copy(compo.Data().DataFileName()); + } + else if (ipc.iAttrType == EDCMetaData) + { + dataFileName.Copy(compo.MetaData().DataFileName()); + } + else + { + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL - ERROR called for illegal item: %d!", ipc.iAttrType ); + User::Leave(KErrArgument); + } + + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL(): using dataFile: (%S)", &dataFileName ); + + // EFileWrite So we can delete the original decoded data file + User::LeaveIfError(file.Open(fs, dataFileName, EFileWrite)); + CleanupClosePushL(file); + if (Server().IsDataFileB64EncodedL(file, length)) + { + RDEBUG( "CApplicationManagementServer::UpdateStreamedDataL(): data is decoded" ); + + TFileName tempFileName; + TBuf<30> privatePath; + fs.PrivatePath(privatePath); + RFile tempFile; + TInt err(KErrNone); + err = tempFile.Temp(fs, privatePath, tempFileName, EFileWrite); + if (err == KErrNone) + { + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL(): created tempFile: (%S)", &tempFileName ); + } + else + { + User::Leave(err); + } + CleanupClosePushL(tempFile); + + TRAP( err, Server().DecodeB64DataFileL( file, tempFile ) ); + if (err != KErrNone) + { + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL - failed to decode datafile: %d", err ); + CleanupStack::PopAndDestroy(2, &file); + compo.ResetDataL(fs); // Remove both files if exists + User::Leave(err); + } + else + { + // close both files, delete decode file and rename temp file to correct one + CleanupStack::PopAndDestroy(2, &file); + fs.Delete(dataFileName); + err = fs.Rename(tempFileName, dataFileName); + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL - successfully decoded datafile: %d", err ); + } + CleanupStack::PopAndDestroy(&fs); + } + else + { + RDEBUG( "ApplicationManagementSession::UpdateStreamedDataL(): data is NOT decoded" ); + CleanupStack::PopAndDestroy(2, &fs); + } + + if (ipc.iAttrType == EDCData) + { + compo.SetDataL(ipc.iDataMime); + } + else + { + compo.SetMetaDataL(ipc.iDataMime); + } + + Server().Storage()->UpdateL(compo); + } + else + { + RDEBUG( "ApplicationManagementSession::UpdateStreamedDataL - ERROR called for illegal state message!" ); + User::Leave(KErrArgument); + } + RDEBUG( "ApplicationManagementSession: UpdateStreamedDataL() End"); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::UpdateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::UpdateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: UpdateL" ); + + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + RDEBUG_2("ApplicationManagementSession: UpdateL id is %d", id ); + + TDeplCompAttrType item; + TPckg itemid(item); + TInt read1(aMessage.Read(1, itemid)); + HBufC8 *buf = HBufC8::NewLC(aMessage.GetDesLength(2)); + TPtr8 pbuf(buf->Des()); + TInt read2(aMessage.Read(2, pbuf)); + + CDeploymentComponent &c = Server().Storage()->ComponentL(id); + TDeploymentComponentState st(c.State()); + if (st == EDCSDelivered || st == EDCSDownload) + { + switch (item) + { + case EDCId: + { + c.SetIdL(pbuf); + break; + } + case EDCName: + { + c.SetNameL(pbuf); + break; + } + case EDCVersion: + { + c.SetVersionL(pbuf); + break; + } + case EDCDescriptionRef: + { + c.SetDescriptionL(pbuf); + break; + } + case EDCInstallOptions: + { + c.SetInstallOptsL(pbuf); + break; + } + case EDCMetaData: + { + c.SetMetaDataL(pbuf, KNullDesC8); + break; + } + case EDCPkgID: + { + c.SetPkgIDL(pbuf); + break; + } + case EDCPkgType: + { + c.SetPkgTypeL(pbuf); + break; + } + + default: + { + if (st == EDCSDelivered) + { + switch (item) + { + case EDCData: + { + c.SetDataL(pbuf, KNullDesC8); + if (c.State() == EDCSDownload) + { + // Server().StartDownload( *compo ); + } + break; + } + default: + { + RDEBUG_2("ApplicationManagementSession: ERROR UpdateL called for illegal item type!!!! %d", item ); + User::Leave(KErrArgument); + } + } + } + else if (st == EDCSDownload) + { + switch (item) + { + case EDCId: + { + c.SetIdL(pbuf); + break; + } + case EDCName: + { + c.SetNameL(pbuf); + break; + } + case EDCVersion: + { + c.SetVersionL(pbuf); + break; + } + case EDCDownloadURI: + { + c.SetDownloadURIL(pbuf); + break; + } + case EDCConRef: + { + TPckgBuf aInt; + aInt.Copy(pbuf); + c.SetIAPL(aInt()); + break; + } + default: + { + RDEBUG_2( "ApplicationManagementSession: ERROR UpdateL called for illegal item type!!!! %d", item ); + User::Leave(KErrArgument); + break; + } + } + } + break; + } + } + Server().Storage()->UpdateL(c); + } + else if (st == EDCSActive || st == EDCSInactive) + { + switch (item) + { + case EDCName: + { + c.SetNameL(pbuf); + break; + } + case EDCVersion: + { + c.SetVersionL(pbuf); + break; + } + case EDCDescriptionRef: + { + c.SetDescriptionL(pbuf); + break; + } + default: + { + RDEBUG_2( "ApplicationManagementSession: ERROR UpdateL called for illegal item type!!!! %d", item ); + User::Leave(KErrArgument); + break; + } + } + Server().Storage()->UpdateL(c); + } + else + { + RDEBUG( "ApplicationManagementSession: ERROR UpdateL called for illegal state message!" ); + User::Leave(KErrArgument); + } + CleanupStack::PopAndDestroy(buf); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetDataLengthL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetDataLengthL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetDataLengthL" ); + TUint32 id; + TPckg pid(id); + + TInt read(aMessage.Read(0, pid)); + + TInt length(0); + + TDeplCompAttrType dt; + TPckg pdt(dt); + read = aMessage.Read(1, pdt); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + if (compo.State() == EDCSDelivered) + { + if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet()) + { + length = sizeof(TAMInstallOptions); + } + } + else if (dt == EDCData) + { + length = compo.Data().DataLengthL(); + } + else if (dt == EDCDataMime) + { + length = compo.Data().MimeType().Length(); + } + else if (dt == EDCMetaData) + { + length = compo.MetaData().DataLengthL(); + } + else if (dt == EDCMetaDataMime) + { + length = compo.MetaData().MimeType().Length(); + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataLengthL ERROR called with illegal type %d", dt ); + User::Leave(KErrArgument); + } + } + else if (compo.State() == EDCSDownload) + { + if (dt == EDCDownloadURI) + { + length = compo.DownloadURI().Length(); + } + else if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet()) + { + length = sizeof(TAMInstallOptions); + } + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataLengthL ERROR Download / called with illegal state component id %d", + compo.State() ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataLengthL ERROR called with illegal state component id %d", + compo.State() ); + User::Leave(KErrArgument); + } + + TPckg pcomp(length); + aMessage.Write(2, pcomp); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetDataL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetDataL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetDataL" ); + TUint32 id; + TPckg pid(id); + + TInt read(aMessage.Read(0, pid)); + + TDeplCompAttrType dt; + TPckg pdt(dt); + read = aMessage.Read(1, pdt); + + RDEBUG_3( "ApplicationManagementSession: GetDataL id is %d, and attribute %d", id, dt ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + if (dt == EDCStatus) + { + TPckg p(compo.Status()); + aMessage.Write(2, p); + } + else if (compo.State() == EDCSDelivered) + { + if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet()) + { + TAMInstallOptionsPckgBuf pckg(compo.InstallOpts()); + aMessage.Write(2, pckg); + } + else + { + aMessage.Write(2, KNullDesC8); + } + } + else if (dt == EDCData) + { + aMessage.Write(2, compo.Data().Data()); + } + else if (dt == EDCDataMime) + { + aMessage.Write(2, compo.Data().MimeType()); + } + else if (dt == EDCMetaData) + { + aMessage.Write(2, compo.MetaData().Data()); + } + else if (dt == EDCMetaDataMime) + { + aMessage.Write(2, compo.MetaData().MimeType()); + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataL ERROR called with illegal type %d", dt ); + User::Leave(KErrArgument); + } + } + else if (compo.State() == EDCSDownload) + { + + if (dt == EDCDownloadURI) + { + aMessage.Write(2, compo.DownloadURI()); + } + + else if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet()) + { + TAMInstallOptionsPckgBuf pckg(compo.InstallOpts()); + aMessage.Write(2, pckg); + } + else + { + aMessage.Write(2, KNullDesC8); + } + } + else if (dt == EDCConRef) + { + TPckg p(compo.GetIAP()); + aMessage.Write(2, p); + } + else + { + RDEBUG_2( "ApplicationManagementSession:GetDataL ERROR called with illegal type %d", dt ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG_2("ApplicationManagementSession: GetDataL ERROR called with illegal state component id %d", compo.State() ); + User::Leave(KErrArgument); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::RemoveL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::RemoveL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: RemoveL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read(0, pid)); + RDEBUG_2( "ApplicationManagementSession: RemoveL id is %d", id ); + RemoveInternalL(id); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::RemoveInternalL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::RemoveInternalL(const TUint32 &aId) const + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(aId); + + Server().RemoveInternalL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DownloadL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DownloadL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: DownloadL" ); + + TDCUserId userId; + aMessage.ReadL(1, userId); + CDeploymentComponent *compo = NULL; + + if (iTrustAdded) + { + compo = Server().Storage()->NewComponentL(EDCSDownload, userId, + &iCertInfo); + } + else + { + compo = Server().Storage()->NewComponentL(EDCSDownload, userId); + } + TUint32 i(compo->InternalId()); + TPckg p(i); + aMessage.WriteL(0, p); + RDEBUG( "ApplicationManagementSession: DownloadL end" ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::FullUpdateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::FullUpdateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: FullUpdateL" ); + + TUint32 sid; + + TPckg psid(sid); + TInt read(aMessage.Read(0, psid)); + TUint32 tid; + TPckg ptid(tid); + TInt read2(aMessage.Read(1, ptid)); + + RDEBUG_3( "ApplicationManagementSession: FullUpdateL sid is %d, tid is %d", sid, tid ); + CApplicationManagementServer &server = Server(); + server.FullUpdateL(sid, tid); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ServiceError() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ServiceError(const RMessage2& aMessage, + TInt aError) + { + RDEBUG_2( "ApplicationManagementSession: CApplicationManagementSession::ServiceError %d", aError); + CSession2::ServiceError(aMessage, aError); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::AddTrustL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::AddTrustL(const RMessage2 &aMessage) + { + TPckg pkg(iCertInfo); + aMessage.ReadL(0, pkg); + iTrustAdded = ETrue; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StateChangeComponentIdsL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StateChangeComponentIdsL( + const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsL" ); + RComponentIdArray arr; + Server().Storage()->GetStateChangeComponentIdsL(arr); + TInt buflen(arr.Count()); + TUint32* buf = new (ELeave) TUint32[buflen]; + CleanupArrayDeletePushL(buf); + for (TInt i(0); i < buflen; i++) + { + RDEBUG_2( "ApplicationManagementSession:ComponentIdsL Adding %d!!", arr[i]); + buf[i] = arr[i]; + } + TPtrC8 p((TUint8*) buf, buflen * sizeof(TUint32)); + aMessage.WriteL(0, p); + arr.Close(); + CleanupStack::PopAndDestroy(buf); + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsL end" ); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StateChangeComponentIdsCountL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StateChangeComponentIdsCountL( + const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsCountL" ); + RPointerArray preInstalledAppParams; + CAMPreInstallApp* preInstallApp = CAMPreInstallApp::NewL(); + preInstallApp->GetPreInstalledAppsL(preInstalledAppParams); + TInt count = 0; + for (count = 0; count < preInstalledAppParams.Count(); count++) + { + RDEBUG8_2("CApplicationManagementSession::DownloadL: Installed App Name is: %S",&(preInstalledAppParams[count]->iPreInstalledAppame)); + RDEBUG8_2("CApplicationManagementSession::DownloadL: Installed App Vendor is: %S",&(preInstalledAppParams[count]->iPreInstalledAppVendorName)); + RDEBUG_2("CApplicationManagementSession::DownloadL: Installed App UID is : '0x%X'",preInstalledAppParams[count]->iPreInstalledAppUid); + + TBool found = EFalse; + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + TInt countval(arrt.Count()); + for (TInt i(0); i < countval; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL( + arrt[i]); + if (compo.Uid() + == preInstalledAppParams[count]->iPreInstalledAppUid) + { + RDEBUG( "CApplicationManagementSession: ActiveComponentsL found= TRUE" ); + found = ETrue; + } + } + if (!found) + { + RDEBUG( "CApplicationManagementSession: Adding Pre-installed app" ); + TDCUserId preInstalledAppName; + preInstalledAppName.Copy( + preInstalledAppParams[count]->iPreInstalledAppame); + CDeploymentComponent *preInstallCompo = NULL; + RDEBUG8_2("CApplicationManagementSession: Installed App Name is: %S",&preInstalledAppName); + preInstallCompo = Server().Storage()->NewComponentL(EDCSActive, + preInstalledAppName); + preInstallCompo->SetUid( + preInstalledAppParams[count]->iPreInstalledAppUid); + preInstallCompo->SetNameL(preInstalledAppName); + preInstallCompo->SetVersionL( + preInstalledAppParams[count]->iVersion); + preInstallCompo->SetMimeTypeL( + preInstalledAppParams[count]->iMimeType); + preInstallCompo->SetAppRemovableStatus(ETrue); + + Server().Storage()->UpdateL(*preInstallCompo); + Server().Storage()->CheckForDuplicateNodesInDeployedL( + *preInstallCompo); + } + } + delete preInstallApp; + RComponentIdArray arr; + Server().Storage()->GetStateChangeComponentIdsL(arr); + TPckgBuf buflen(arr.Count()); + aMessage.WriteL(0, buflen); + arr.Close(); + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsCountL end" ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StateChangeCompleteL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StateChangeCompleteL( + const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: StateChangeCompleteL" ); + TUint32 tid; + TPckg ptid(tid); + TInt read2(aMessage.Read(0, ptid)); + Server().Storage()->StateChangedL(tid); + } +void CApplicationManagementSession::CheckStatusNodesValuesL() + { + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + TInt cont(arrt.Count()); + TBool isUpdateRequired = ETrue; + for (TInt i(0); i < cont; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(arrt[i]); + isUpdateRequired = EFalse; + if (compo.Status() == EDownload_DownloadProgress) + { + compo.SetStatusNode(EDownload_DownloadFailed); + isUpdateRequired = ETrue; + } + else if (compo.Status() == EDelivered_InstallProgress) + { + compo.SetStatusNode(EDelivered_InstalledFailedWithData); + isUpdateRequired = ETrue; + } + else if (compo.Status() == EDelivered_RemoveProgress) + { + compo.SetStatusNode(EDelivered_RemoveFailed); + isUpdateRequired = ETrue; + } + else if (compo.Status() == EDeployed_RemoveProgress) + { + compo.SetStatusNode(EDeployed_RemoveFailed); + isUpdateRequired = ETrue; + } + else if (compo.Status() == EDeployed_ActivateProgress) + { + compo.SetStatusNode(EDeployed_ActivateFailed); + isUpdateRequired = ETrue; + } + else if (compo.Status() == EDeployed_DeactivateProgress) + { + compo.SetStatusNode(EDeployed_DeactivateFailed); + isUpdateRequired = ETrue; + } + if (isUpdateRequired) + Server().Storage()->UpdateL(compo); + } + + } + +void CApplicationManagementServer::SetSisAppVersionAndDriveL( + CDeploymentComponent &aCompo) + { + RDEBUG( "CApplicationManagementSession: SetSisAppVersionAndDriveL: Begin" ); + + Swi::RSisRegistrySession sisSession; + User::LeaveIfError(sisSession.Connect()); + CleanupClosePushL(sisSession); + + Swi::RSisRegistryEntry sisEntry; + + //Opens the base package entry by specifying a UID. + User::LeaveIfError(sisEntry.Open(sisSession, aCompo.Uid())); + CleanupClosePushL(sisEntry); + + TUint drivesMask = sisEntry.InstalledDrivesL(); + + TInt drive = EDriveA; + TDriveNumber installedDrive = EDriveC; + + if (drivesMask) + { + // Select the highest drive as location drive. That's the case when + // all installation is not in same drive + + while (drivesMask >>= 1) + { + drive++; + } + + RDEBUG_2( "drive -> SetSisAppVersionAndDriveL %d", drive); + + installedDrive = (TDriveNumber) drive; + } + + TBool status = EFalse; + + //Since "C" drive is not removable + + if (installedDrive != EDriveC) + { + status = IsInstalledAppRemovableL(installedDrive); + } + if (status) + { + RDEBUG( "IsInstalledAppRemovableL(SetSisAppVersionAndDriveL); True"); + } + else + { + RDEBUG( "IsInstalledAppRemovableL(SetSisAppVersionAndDriveL); False"); + } + + //check for status drive + aCompo.SetAppRemovableStatus(status); + + TVersion version = sisEntry.VersionL(); + + if (aCompo.ComponentVersion() == KNullDesC8) + { + TBuf8 pkgDes; + pkgDes.AppendNum(version.iMajor); + pkgDes.Append(KLiteralPeriod); + pkgDes.AppendNum(version.iMinor); + aCompo.SetVersionL(pkgDes); + + } + CleanupStack::PopAndDestroy(2, &sisSession); + + RDEBUG( "CApplicationManagementSession: SetSisAppVersionAndDriveL: End" ); + } + +TBool CApplicationManagementServer::IsInstalledAppRemovableL( + TDriveNumber &iDrive) + { + RDEBUG( "IsInstalledAppRemovableL: Step1" ); + TBool removable = EFalse; + RFs rfs; + User::LeaveIfError(rfs.Connect()); + CleanupClosePushL(rfs); + TDriveList driveList; + TInt driveCount; + + //Get all removeable drive, both physically and logically + User::LeaveIfError(DriveInfo::GetUserVisibleDrives(rfs, driveList, + driveCount, KDriveAttRemovable)); + + TInt max(driveList.Length()); + + RDEBUG_2( "driveList.Length() %d", max); + + RDEBUG_2( "driveCount %d", driveCount); + + TBuf<26> buf; + buf.Copy(driveList); + RDEBUG_2( "Drive Info (%S)", &buf); + + for (TInt i = 0; i < max; ++i) + { + if (driveList[i]) + { + TUint status; + RDEBUG( "IsInstalledAppRemovableL: Step3" ); + DriveInfo::GetDriveStatus(rfs, i, status); + + RDEBUG( "IsInstalledAppRemovableL: Step4" ); + //To make sure the drive is physically removeable not logically removeable + if (status & DriveInfo::EDriveRemovable) + { + RDEBUG( "IsInstalledAppRemovableL: Drive removable" ); + RDEBUG_2( "IsInstalledAppRemovableL: Drive removable Drive ID %d", i); + if (i == iDrive) + { + RDEBUG( "IsInstalledAppRemovableL: Step5" ); + removable = ETrue; + break; + } + } + } + } + + CleanupStack::PopAndDestroy(&rfs); + + return removable; + } + +// ----------------------------------------------------------------------------- +// CShutDown::CShutdown() +// ------------------------------------------------------------------------------------------------ + +inline CShutdown::CShutdown() : + CTimer(-1) + { + CActiveScheduler::Add(this); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::ConstructL() +// ------------------------------------------------------------------------------------------------ + +inline void CShutdown::ConstructL() + { + CTimer::ConstructL(); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::Start() +// ------------------------------------------------------------------------------------------------ + +inline void CShutdown::Start() + { + RDEBUG( "ApplicationManagementServer: starting shutdown timeout" ); + After(KApplicationManagementShutdownDelay); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::RunL() +// ------------------------------------------------------------------------------------------------ + +void CShutdown::RunL() + { + RDEBUG( "ApplicationManagementServer timeout ... closing" ); + HbApplication::exit(0); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::Start() +// ------------------------------------------------------------------------------------------------ +inline void CShutdown::Stop() + { + RDEBUG( "ApplicationManagementServer: Stop" ); + HbApplication::exit(0); + } + +// End of File