--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applicationmanagement/server/src/ApplicationManagementServer.cpp Thu Dec 17 08:40:12 2009 +0200
@@ -0,0 +1,3871 @@
+/*
+ * 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 <e32svr.h>
+#include <badesca.h>
+#include <e32cmn.h>
+#include <bautils.h>
+#include <featmgr.h>
+#include <imcvcodc.h>
+#include <uikon.hrh>
+#include <e32property.h>
+#include "ApplicationManagementConst.h"
+#include "ampskeys.h"
+#include <SWInstDefs.h>
+#include "amprivateCRKeys.h"
+#include <PolicyEngineClient.h>
+#include <PolicyEngineXACML.h>
+#include <pathinfo.h>
+#include <driveinfo.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 <aknnotewrappers.h>
+#include "SyncService.h"
+#include "AMPreInstallApp.h"
+#include <DevManInternalCRKeys.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/");
+
+// ------------------------------------------------------------------------------------------------
+// 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" );
+ CActiveScheduler::Stop();
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CShutDown::Start()
+// ------------------------------------------------------------------------------------------------
+
+inline void CShutdown::Stop()
+ {
+ RDEBUG( "ApplicationManagementServer: Stop" );
+ CActiveScheduler::Stop();
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::CreateServiceL()
+// ------------------------------------------------------------------------------------------------
+CApaAppServiceBase* CApplicationManagementServer::CreateServiceL(
+ TUid aServiceType) const
+ {
+ RDEBUG( "ApplicationManagementServer CreateServiceL" );
+ if (aServiceType.iUid == KAMServiceUid)
+ {
+ return ((CApaAppServiceBase*) (new (ELeave) CApplicationManagementSession));
+ }
+ else
+ {
+ return CAknAppServer::CreateServiceL(aServiceType);
+ }
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::SendServerToBackground()
+// ------------------------------------------------------------------------------------------------
+
+void CApplicationManagementServer::SendServerToBackground()
+ {
+
+ RDEBUG( "ApplicationManagementServer SendServerToBackground - Start " );
+ TApaTaskList taskList(CEikonEnv::Static()->WsSession() );
+ TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid));
+
+ TInt id = CEikonEnv::Static()->RootWin().Identifier();
+
+ RDEBUG_2( "CApplicationManagementServer:::SendServerToBackground %d", id );
+
+ task.SetWgId(id);
+
+ if (task.Exists())
+ {
+ RDEBUG( "ApplicationManagementServer SendServerToBackground - Start 1" );
+ task.SendToBackground();
+ }
+ RDEBUG( "ApplicationManagementServer SendServerToBackground - End " );
+ TInt amServerEnabled = 0;
+ RProperty::Set(KUidPSApplicationManagementKeys, KAMServerUIEnabled,
+ amServerEnabled);
+ RDEBUG( "ApplicationManagementServer SendServerToBackground - End 2 " );
+
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::BringServertoForeground()
+// ------------------------------------------------------------------------------------------------
+
+void CApplicationManagementServer::BringServertoForeground()
+ {
+
+ RDEBUG( "CApplicationManagementServer:::BringServertoForeground " );
+ TApaTaskList taskList(CEikonEnv::Static()->WsSession() );
+ TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid));
+
+ TInt id = CEikonEnv::Static()->RootWin().Identifier();
+
+ RDEBUG_2( "CApplicationManagementServer:::BringServertoForeground %d", id );
+
+ task.SetWgId(id);
+ if (task.Exists())
+ {
+ RDEBUG( "ApplicationManagementServer SendServerToBackground - BringServertoForeground " );
+ task.BringToForeground();
+ }
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::BringServertoForeground()
+// ------------------------------------------------------------------------------------------------
+
+void CApplicationManagementServer::BringDMUItoForeground()
+ {
+ RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground Start " );
+
+ TApaTaskList taskList(CEikonEnv::Static()->WsSession() );
+ TApaTask task = taskList.FindApp(KPSUidNSmlDMSyncApp);
+
+ const TInt id = task.WgId();
+ task.SetWgId(id);
+ RDEBUG_2( "CApplicationManagementServer:::BringDMUItoForeground %d", id );
+
+ if (task.Exists())
+ {
+ RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground " );
+ task.BringToForeground();
+ }
+ }
+
+// ------------------------------------------------------------------------------------------------
+// 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() );
+ 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));
+ if (trgt == EInstall && errInstall == KErrNone)
+ {
+ iStorage->DeactivateL( *aComponent);
+ }
+ /* to avoid duplicates in deployed tree if user delivered upgrade package
+ * by using "Install/InstallActivate" operation. if upgrade package is delivered
+ * by Update/UpdateandActivate" , this been handled in next switch case
+ */
+
+ 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.
+
+ SendServerToBackground();
+
+ // Bring DM UI to foreground provided operation is in non silent mode.
+ TInt operNonSilent = KErrNotFound;
+
+ RProperty::Get(KUidPSApplicationManagementKeys, KAMOperationNonSilent,
+ operNonSilent);
+
+ if (operNonSilent==1 || operNonSilent==KErrNotFound)
+ {
+ RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Bring " );
+ BringDMUItoForeground();
+ }
+
+ iOMASCOMOEnabled = IsOMASCOMOEnabledL();
+
+
+ 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
+ {
+
+ // Get deployement component entries
+ TInt internalid = aComponent->InternalId();
+
+ TBuf8<256> targetURI;
+
+ TDeploymentComponentState state = aComponent->State();
+
+ if (state == EDCSDownload)
+ {
+ targetURI.Append(KDownloadState);
+ targetURI.Append(aComponent->UserId());
+ }
+ else
+ if (state == EDCSDelivered)
+ {
+ targetURI.Append(KDeliveredState);
+ targetURI.Append(aComponent->UserId());
+
+ }
+ else
+ if (state == EDCSActive|| state == EDCSInactive)
+ {
+ targetURI.Append(KDeployedState);
+ targetURI.Append(aComponent->UserId());
+ }
+
+ //Save Entry to database with status and target URI of deployment component
+
+ TInt index;
+ iAMServerDB->SaveToDatabaseL(index, internalid, status,
+ targetURI, iapid);
+
+ EnableDMNetworkMonL(iapid, aServerId);
+ }
+
+ }
+ 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.Stop();
+ }
+ }
+
+ RDEBUG( "ApplicationManagementServer DownloadComplete - end" );
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::IsOMASCOMOEnabledL()
+// ------------------------------------------------------------------------------------------------
+
+TBool CApplicationManagementServer::IsOMASCOMOEnabledL()
+ {
+ TInt adapterValue;
+
+ CRepository *repository = CRepository::NewLC ( KCRUidPrivateApplicationManagementKeys ) ;
+ repository->Get(KAMAdapterValue, adapterValue);
+ CleanupStack::PopAndDestroy();
+
+ 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;
+ 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 );
+ repository->Set(KDevManEnableDMNetworkMon, retryenabled);
+ repository->Set(KDevManServerIdKey, *aServerId);
+ repository->Set(KDevManIapIdKey, iapid);
+ 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()
+ {
+ }
+
+// ------------------------------------------------------------------------------------------------
+// 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() );
+ iDownloadMngr->AddDownloadL(aComponent);
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::NewLC
+// ------------------------------------------------------------------------------------------------
+
+CApplicationManagementServer* CApplicationManagementServer::NewL()
+ {
+
+ CApplicationManagementServer* self=new(ELeave) CApplicationManagementServer;
+
+ return self;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::CreateServiceSecurityCheckL
+// ------------------------------------------------------------------------------------------------
+
+CPolicyServer::TCustomResult CApplicationManagementServer::CreateServiceSecurityCheckL(
+ TUid aServiceType, const RMessage2& aMsg, TInt& aAction,
+ TSecurityInfo& aMissing)
+ {
+ TInt32 trustRange = EAddTrust;
+ TInt32 performRFS = EPerformRfs;
+ TInt32 last = ELast;
+
+ if ( (aServiceType.iUid >= trustRange)
+ && (aServiceType.iUid < performRFS ))
+ {
+ if (aMsg.HasCapability(TCapability(ECapabilityTrustedUI) ) )
+ {
+ return CPolicyServer::EPass;
+ }
+ else
+ {
+ return CPolicyServer::EFail;
+ }
+ }
+
+ else
+ if ( (aServiceType.iUid >= performRFS) && (aServiceType.iUid < last))
+
+ {
+ if (aMsg.HasCapability(TCapability(ECapabilityDiskAdmin))
+ && (aMsg.SecureId().iId == 0x101f9a02 ))
+ {
+ return CPolicyServer::EPass;
+ }
+ else
+ {
+ return CPolicyServer::EFail;
+ }
+ }
+
+ else
+ if (aServiceType.iUid == last)
+ {
+ return CPolicyServer::EFail;
+ }
+
+ else
+ {
+ return CAknAppServer::CreateServiceSecurityCheckL(
+ aServiceType, aMsg, aAction, aMissing);
+ }
+
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::~CApplicationManagementServer
+// ------------------------------------------------------------------------------------------------
+
+CApplicationManagementServer::~CApplicationManagementServer()
+ {
+ RDEBUG_3("CApplicationManagementServer::~CApplicationManagementServer 0x%X - 0x%X", reinterpret_cast<TUint>(this ),
+ reinterpret_cast<TUint>(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(const TDesC &aServerName)
+ {
+
+ // 2nd phase construction - ensure the timer and server objects are running
+ RDEBUG( "CApplicationManagementServer::ConstructL - Start" );
+
+ iOMASCOMOEnabled = ETrue;
+
+ CAknAppServer::ConstructL(aServerName);
+ TRAPD( errf, FeatureManager::InitializeLibL() )
+ ;
+ if (errf != KErrNone)
+ {
+ User::Leave(errf);
+ }
+
+ RDEBUG( "CApplicationManagementServer::ConstructL - start" );
+
+ iStorage = CDeliveryComponentStorage::NewL();
+
+ iUtility
+ = ApplicationManagementUtilityFactory::CreateManagementUtilityL();
+ iDownloadMngr = CAMDownloadManager::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();
+
+ SendServerToBackground();
+
+#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
+ RDEBUG( "CApplicationManagementServer::ConstructL - end" );
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::StartShutDownTimer()
+// ------------------------------------------------------------------------------------------------
+
+void CApplicationManagementServer::StartShutDownTimerL()
+ {
+
+ RDEBUG( "CApplicationManagementServer::ConstructL - end" );
+
+ iShutdown.ConstructL();
+ // ensure that the server still exits even if the 1st client fails to connect
+ iShutdown.Start();
+
+ RDEBUG( "CApplicationManagementServer::ConstructL - end" );
+ }
+
+// ------------------------------------------------------------------------------------------------
+// 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) );
+ }
+
+ if (aInstallSuccess)
+ {
+ // Remove temporary files from private directory
+ const_cast<CDeploymentComponent&>(aCompo).ResetDataL(iInstallRFs);
+ }
+
+ 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" );
+ return res;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// CApplicationManagementServer::InstallL()
+// ------------------------------------------------------------------------------------------------
+
+void CApplicationManagementServer::InstallL(
+ const CDeploymentComponent &aComponent, TRequestStatus &aStatus)
+ {
+ RDEBUG( "CApplicationManagementServer::InstallL (async): begin" );
+
+ if (iInstallInProgress == EFalse)
+ {
+ TFileName fn;
+ if (PrepareInstallL(aComponent, fn) )
+ {
+ RDEBUG_3( "CApplicationManagementServer::InstallL: Install '%S' sizeof opts: %d", &fn, sizeof (aComponent.InstallOpts()));
+
+ // Silent or Non Silent Installation is choosen based on DM session started in silent or non silent
+
+ TInt err = KErrNone;
+ TInt nonSilentOperation = KErrNotFound;
+ RProperty::Get(KUidPSApplicationManagementKeys,
+ KAMOperationNonSilent, nonSilentOperation);
+
+ if (!nonSilentOperation)
+ {
+ TRAP( err ,iInstaller.SilentInstall( aStatus, iInstallFile, iInstallReq, iInstallOptions ) );
+ }
+ else
+ {
+ TRAP( err ,iInstaller.Install( aStatus, iInstallFile, iInstallReq ) );
+ }
+
+ 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);
+ TRAPD( err ,iInstaller.SilentInstall( fn, pkg ) )
+ ;
+ User::LeaveIfError(err);
+ 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();
+
+ TInt nonSilentOperation = KErrNotFound;
+
+ RProperty::Get(KPSUidNSmlDMSyncApp, KSilentSession,
+ nonSilentOperation);
+
+ iOMASCOMOEnabled = IsOMASCOMOEnabledL();
+
+ if (!iOMASCOMOEnabled)
+ nonSilentOperation = 0;
+ if (!nonSilentOperation)
+ {
+ TRAP( err ,iInstaller.SilentUninstall( aStatus, aComponent.Uid(),
+ iUninstallOptions, aComponent.MimeType() ) );
+ }
+ else
+ {
+ TRAP( err ,iInstaller.Uninstall( aStatus, aComponent.Uid(), aComponent.MimeType() ) );
+ CSyncService *syncService =
+ CSyncService::NewL(NULL, KDevManServiceStart);
+ if (syncService)
+ {
+ syncService->EnableProgressNoteL(EFalse);
+ }
+
+ delete syncService;
+ }
+
+ 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() );
+
+ aCompo.SetStatusNode(EDelivered_RemoveProgress);
+ TInt err(KErrNone);
+ TDeploymentComponentState st(aCompo.State() );
+ if (st == EDCSDelivered || st == EDCSDownload)
+ {
+ TRAP(err,iStorage->RemoveL( aCompo.InternalId() ));
+ }
+ else
+ if (st == EDCSActive || st == EDCSInactive)
+ {
+ if (aDoUninstall)
+ {
+ if (aCompo.Uid() != TUid::Null() )
+ {
+ //TInt err= KErrNone;
+
+ TInt nonSilentOperation = KErrNotFound;
+
+ RProperty::Get(KPSUidNSmlDMSyncApp, KSilentSession,
+ nonSilentOperation);
+
+ iOMASCOMOEnabled = IsOMASCOMOEnabledL();
+
+ if (!iOMASCOMOEnabled)
+ nonSilentOperation = 0;
+
+ if (nonSilentOperation!=0)
+ {
+
+ BringServertoForeground();
+
+ TInt amServerEnabled = 1;
+ err = RProperty::Set(KUidPSApplicationManagementKeys,
+ KAMServerUIEnabled, amServerEnabled);
+ User::LeaveIfError(err); // invalid
+
+ }
+
+ TRequestStatus s;
+ TRAP(err,UninstallL( aCompo, s ));
+ User::WaitForRequest(s);
+ iInstallInProgress = EFalse;
+ // Capturing Installer errors,if any
+ err = s.Int();
+
+ TInt amServerEnabled = 0;
+ RProperty::Set(KUidPSApplicationManagementKeys,
+ KAMServerUIEnabled, amServerEnabled);
+ //User::LeaveIfError(err); // invalid
+
+ SendServerToBackground();
+
+ // Bring DM UI to foreground
+ if (nonSilentOperation!=0)
+ {
+ BringDMUItoForeground();
+ }
+
+ if (s.Int() == KErrNone)
+ {
+ RDEBUG("CApplicationManagementServer::RemoveInternalL Uninstalled");
+ }
+ else
+ 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
+ {
+ 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);
+ }
+ 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<TUid> 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<TUid> &aUidsOrig,
+ const RArray<TUid> &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<TUid> &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 progress
+ aCompo.SetStatusNode(EDelivered_InstallProgress);
+ TRAP(err,InstallL( aCompo,s ));
+ if (err != KErrNone)
+ {
+ aCompo.SetStatusNode(EDelivered_InstalledFailedWithData);
+ User::Leave(err);
+ }
+ User::WaitForRequest(s);
+ SendServerToBackground();
+ if (s != KErrNone)
+ {
+ RDEBUG_2( "ApplicationManagementSession: JavaInstallL failed with code %d",
+ s.Int() );
+ // set state to install failed with data
+ aCompo.SetStatusNode(EDelivered_InstalledFailedWithData);
+ User::Leave(s.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;
+ // set state to install progress
+ aCompo.SetStatusNode(EDelivered_InstallProgress);
+ TInt err(KErrNone);
+ TRAP(err,InstallL( aCompo,s ));
+ if (err != KErrNone)
+ {
+ aCompo.SetStatusNode(EDelivered_InstalledFailedWithData);
+ User::Leave(err);
+ }
+ User::WaitForRequest(s);
+ if (s != KErrNone)
+ {
+ RDEBUG_2("ApplicationManagementSession: SisInstallL failed with code %d",
+ s.Int() );
+ // set state to install failed with data
+ aCompo.SetStatusNode(EDelivered_InstalledFailedWithData);
+ User::Leave(s.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);
+ if (CDeploymentComponent::IsJavaMimeL(aCompo.Data().MimeType() )
+ || CDeploymentComponent::IsJavaMimeL(aCompo.MetaData().MimeType() ) )
+ {
+ TRAP( error, JavaInstallL( aCompo ) );
+ }
+ else
+ {
+ TRAP( error, SisInstallL( aCompo ) );
+ SetSisAppVersionAndDriveL(aCompo);
+ }
+
+ SendServerToBackground();
+
+ 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);
+ }
+ 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 <CDeploymentComponent &>(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<CAMDbItem> 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);
+ // TInt s2( aTarget.Size());
+ aTarget.Compress();
+ // TInt s3( aTarget.Size() );
+ 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<CApplicationManagementServer*>( const_cast<CServer2*>(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();
+ CAknAppServiceBase::CreateL();
+ }
+
+// -------------------------------------------------------------------------------------------------------------------
+// CApplicationManagementSession::~CApplicationManagementSession()
+// -------------------------------------------------------------------------------------------------------------------
+
+CApplicationManagementSession::~CApplicationManagementSession()
+ {
+ RDEBUG_3("CApplicationManagementSession::~CApplicationManagementSession 0x%X - 0x%X", reinterpret_cast<TUint>(this),
+ reinterpret_cast<TUint>(this)+sizeof( CApplicationManagementSession ) );
+ RDEBUG_2("CApplicationManagementSession::~CApplicationManagementSession iCertInfo offs 0x%X",
+ reinterpret_cast<TUint>(&this->iCertInfo) - reinterpret_cast<TUint>(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<TUint32> 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<TUint32> 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<TInt> 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<TDeploymentComponentState> 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<TInt> 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<TUid> uids;
+ sisses.InstalledUidsL(uids);
+ CleanupClosePushL(uids);
+ TInt cont(aArrt.Count() );
+ TInt uidc(uids.Count() );
+ RArray<TUid> 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)
+ 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<TDeploymentComponentState> 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< TDeploymentComponentIPC> 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< TDeploymentComponent> pcomp2(comp.iComponent);
+ aMessage.Write( 0, pcomp2);
+ CleanupStack::PopAndDestroy(data) ;
+ TInt n(compo->InternalId() );
+ TPckg<TUint32> p(n);
+ aMessage.WriteL( 2, p);
+ }
+
+// -------------------------------------------------------------------------------------------------------------------
+// CApplicationManagementSession::DeliverCompleteL()
+// -------------------------------------------------------------------------------------------------------------------
+
+void CApplicationManagementSession::DeliverCompleteL(const RMessage2& aMessage) const
+ {
+ RDEBUG( "ApplicationManagementSession: DeliverCompleteL" );
+ TUint32 id;
+ TPckg<TUint32> 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<TUint32> 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< TDeploymentComponent> pcomp(comp);
+ aMessage.Write( 1, pcomp);
+ }
+
+// -------------------------------------------------------------------------------------------------------------------
+// CApplicationManagementSession::StartDownloadL()
+// -------------------------------------------------------------------------------------------------------------------
+
+void CApplicationManagementSession::StartDownloadL(const RMessage2& aMessage) const
+ {
+ RDEBUG( "ApplicationManagementSession: StartDownloadL" );
+ TUint32 id = 0;
+ TPckg<TUint32> pid(id);
+ TInt read(aMessage.Read( 0, pid) );
+
+ TPckgBuf<TDownloadTarget> 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<TUint32> 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<TUint32> 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<TUint32> 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<TUint32> pid(id);
+ TInt read(aMessage.Read( 0, pid) );
+
+ TDeplCompAttrType item;
+ TPckg<TDeplCompAttrType> 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<Swi::CSisRegistryPackage> 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<Swi::CSisRegistryPackage> 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<TUint32> pid(id);
+ TInt read(aMessage.Read( 0, pid) );
+
+ TDeploymentComponentState targetst;
+ TPckg<TDeploymentComponentState> 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<TDeplCompDataIPC> 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<TDeplCompDataIPC> 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<TUint32> pid(id);
+ TInt read(aMessage.Read( 0, pid) );
+ RDEBUG_2("ApplicationManagementSession: UpdateL id is %d", id );
+
+ TDeplCompAttrType item;
+ TPckg<TDeplCompAttrType> 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<TInt> 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<TUint32> pid(id);
+
+ TInt read(aMessage.Read( 0, pid) );
+
+ TInt length( 0);
+
+ TDeplCompAttrType dt;
+ TPckg< TDeplCompAttrType> 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< TInt> pcomp(length);
+ aMessage.Write( 2, pcomp);
+ }
+
+// -------------------------------------------------------------------------------------------------------------------
+// CApplicationManagementSession::GetDataL()
+// -------------------------------------------------------------------------------------------------------------------
+
+void CApplicationManagementSession::GetDataL(const RMessage2& aMessage) const
+ {
+ RDEBUG( "ApplicationManagementSession: GetDataL" );
+ TUint32 id;
+ TPckg<TUint32> pid(id);
+
+ TInt read(aMessage.Read( 0, pid) );
+
+ TDeplCompAttrType dt;
+ TPckg< TDeplCompAttrType> 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<TInt> 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<TInt> 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<TUint32> 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<TUint32> p(i);
+ aMessage.WriteL(0, p);
+ }
+
+// -------------------------------------------------------------------------------------------------------------------
+// CApplicationManagementSession::FullUpdateL()
+// -------------------------------------------------------------------------------------------------------------------
+
+void CApplicationManagementSession::FullUpdateL(const RMessage2& aMessage) const
+ {
+ RDEBUG( "ApplicationManagementSession: FullUpdateL" );
+
+ TUint32 sid;
+
+ TPckg<TUint32> psid(sid);
+ TInt read(aMessage.Read( 0, psid) );
+ TUint32 tid;
+ TPckg<TUint32> 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<TCertInfo> 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<TPreInstalledAppParams> 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);
+ Server().Storage()->UpdateL( *preInstallCompo );
+ Server().Storage()->CheckForDuplicateNodesInDeployedL(*preInstallCompo);
+ }
+ }
+ delete preInstallApp;
+ RComponentIdArray arr;
+ Server().Storage()->GetStateChangeComponentIdsL(arr);
+ TPckgBuf<TInt> 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<TUint32> 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<KVersionLength> 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)
+ {
+
+ //RDEBUG( "IsInstalledAppRemovableL: Step2" );
+ 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;
+
+ }
+// End of File