/*
* Copyright (c) 2005-2009 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: CSConAppInstaller implementation
*
*/
// INCLUDE FILES
#include <pathinfo.h>
#include <swi/sisregistryentry.h>
#include <swi/sisregistrypackage.h>
#include <swi/sisregistrysession.h>
#include <SWInstDefs.h>
#include <mmf/common/mmfcontrollerpluginresolver.h>
#include <javaregistry.h>
using namespace Java;
#include "debug.h"
#include "sconinstaller.h"
#include "sconpcdconsts.h"
#include "sconpcdutility.h"
_LIT8( KWidgetMimeType, "application/x-nokia-widget");
const TInt KSConSeConUidValue = 0x101f99f6;
const TUid KSConSeConUid = {KSConSeConUidValue};
// ============================= MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CSConAppInstaller::CSConAppInstaller( CSConInstallerQueue* aQueue )
// Constructor
// -----------------------------------------------------------------------------
//
CSConAppInstaller::CSConAppInstaller( CSConInstallerQueue* aQueue, RFs& aFs ) :
CActive( EPriorityStandard ), iQueue( aQueue ), iFs( aFs )
{
TRACE_FUNC;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::~CSConAppInstaller()
// Destructor
// -----------------------------------------------------------------------------
//
CSConAppInstaller::~CSConAppInstaller()
{
TRACE_FUNC;
iSWInst.Close();
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::StartInstaller( TInt& aTaskId )
// Starts the installer task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::StartInstaller( TInt& aTaskId )
{
TRACE_FUNC_ENTRY;
CSConTask* task = NULL;
TRequestStatus* status = NULL;
TInt err( KErrNone );
TInt ret = iQueue->GetTask( aTaskId, task );
if( aTaskId > 0 && ret != KErrNotFound )
{
if ( iInstallerState != EIdle || IsActive() )
{
LOGGER_WRITE("WARNING! SConAppInstaller was not on idle state!");
iQueue->CompleteTask( aTaskId, KErrInUse );
TRACE_FUNC_EXIT;
return;
}
iCurrentTask = aTaskId;
iQueue->SetTaskProgress( aTaskId, KSConCodeProcessingStarted );
switch( task->GetServiceId() )
{
case EInstall :
iQueue->ChangeQueueProcessStatus();
err = iSWInst.Connect();
if( err == KErrNone )
{
if ( task->iInstallParams->iMode == ESilentInstall )
{
LOGGER_WRITE( "Begin silent installation.. " );
iOptions.iUntrusted = SwiUI::EPolicyNotAllowed;
iOptions.iOCSP = SwiUI::EPolicyNotAllowed;
iOptionsPckg = iOptions;
iInstallerState = ESilentInstalling;
iSWInst.SilentInstall( iStatus, task->iInstallParams->iPath, iOptionsPckg );
}
else
{
LOGGER_WRITE( "Begin to install.. " );
iInstallerState = EInstalling;
iSWInst.Install( iStatus, task->iInstallParams->iPath );
}
}
break;
case EUninstall :
iQueue->ChangeQueueProcessStatus();
err = iSWInst.Connect();
if( err == KErrNone )
{
LOGGER_WRITE( "Begin to uninstall.. " );
TRAP( err, ProcessUninstallL( *task->iUninstallParams ) );
if( err != KErrNone )
{
LOGGER_WRITE_1( "StartInstaller ProcessUninstallL err: %d", err );
status = &iStatus;
User::RequestComplete( status, err );
}
}
break;
case EListInstalledApps :
iQueue->ChangeQueueProcessStatus();
iInstallerState = EListingInstalledApps;
TRAP( err, ProcessListInstalledAppsL() );
status = &iStatus;
User::RequestComplete( status, err );
break;
default :
break;
}
SetActive();
}
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::StopInstaller( TInt& aTaskId )
// Stops the installer task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::StopInstaller( TInt& aTaskId )
{
TRACE_FUNC_ENTRY;
//If the task is the current task, cancel it first
if( iCurrentTask == aTaskId )
{
Cancel();
iSWInst.Close();
}
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// TBool CSConAppInstaller::InstallerActive()
// returns installer activity status
// -----------------------------------------------------------------------------
//
TBool CSConAppInstaller::InstallerActive() const
{
if ( iInstallerState == EIdle )
{
return EFalse;
}
else
{
return ETrue;
}
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::DoCancel()
// Implementation of CActive::DoCancel()
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::DoCancel()
{
TRACE_FUNC_ENTRY;
switch (iInstallerState)
{
case EInstalling:
LOGGER_WRITE("Cancel normal install");
iSWInst.CancelAsyncRequest( SwiUI::ERequestInstall );
break;
case ESilentInstalling:
LOGGER_WRITE("Cancel silent install");
iSWInst.CancelAsyncRequest( SwiUI::ERequestSilentInstall );
break;
case EUninstalling:
LOGGER_WRITE("Cancel normal uninstall");
iSWInst.CancelAsyncRequest( SwiUI::ERequestUninstall );
break;
case ESilentUninstalling:
LOGGER_WRITE("Cancel silent uninstall");
iSWInst.CancelAsyncRequest( SwiUI::ERequestSilentUninstall );
break;
case ECustomUninstalling:
LOGGER_WRITE("Cancel custom uninstall");
iSWInst.CancelAsyncRequest( SwiUI::ERequestCustomUninstall );
break;
case ESilentCustomUnistalling:
LOGGER_WRITE("Cancel silent custom uninstall");
iSWInst.CancelAsyncRequest( SwiUI::ERequestSilentCustomUninstall );
break;
default:
LOGGER_WRITE("WARNING! Unknown state");
break;
}
iInstallerState = EIdle;
// find and complete current task
CSConTask* task = NULL;
TInt ret = iQueue->GetTask( iCurrentTask, task );
if ( iCurrentTask > 0 && ret != KErrNotFound )
{
switch( task->GetServiceId() )
{
case EInstall :
iQueue->CompleteTask( iCurrentTask, KErrCancel );
break;
case EUninstall :
iQueue->CompleteTask( iCurrentTask, KErrCancel );
break;
default :
break;
}
}
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::RunL()
// Implementation of CActive::RunL()
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::RunL()
{
TRACE_FUNC_ENTRY;
iInstallerState = EIdle;
iSWInst.Close();
iQueue->ChangeQueueProcessStatus();
TInt err( iStatus.Int() );
LOGGER_WRITE_1( "CSConAppInstaller::RunL() iStatus.Int() : returned %d", err );
CSConTask* task = NULL;
TInt taskErr = iQueue->GetTask( iCurrentTask, task );
LOGGER_WRITE_1( "CSConAppInstaller::RunL() GetTask %d", taskErr );
if( taskErr == KErrNone )
{
if( task->GetServiceId() == EInstall && err == KErrNone )
{
LOGGER_WRITE( "CSConAppInstaller::RunL() : before DeleteFile" );
//delete sis after succesfull install
DeleteFile( task->iInstallParams->iPath );
}
}
iQueue->CompleteTask( iCurrentTask, err );
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::ProcessUninstallL( const CSConUninstall& aUninstallParams )
// Execures UnInstall task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::ProcessUninstallL( const CSConUninstall& aUninstallParams )
{
TRACE_FUNC_ENTRY;
LOGGER_WRITE_1( "aUid: 0x%08x", aUninstallParams.iUid.iUid );
LOGGER_WRITE_1( "aName: %S", &aUninstallParams.iName );
LOGGER_WRITE_1( "aVendor: %S", &aUninstallParams.iVendor );
LOGGER_WRITE_1( "aType: %d", aUninstallParams.iType );
LOGGER_WRITE_1( "aMode: %d", aUninstallParams.iMode );
switch ( aUninstallParams.iType )
{
case ESisApplication:
case ESisAugmentation:
UninstallSisL( aUninstallParams );
break;
case EJavaApplication:
UninstallJavaL( aUninstallParams.iUid,
aUninstallParams.iMode);
break;
case EWidgetApplication:
UninstallWidget( aUninstallParams.iUid,
aUninstallParams.iMode );
break;
default:
User::Leave( KErrNotSupported );
}
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::UninstallSisL( const CSConUninstall& aUninstallParams )
// Uninstall sis package or augmentation
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::UninstallSisL( const CSConUninstall& aUninstallParams )
{
TRACE_FUNC_ENTRY;
if ( aUninstallParams.iUid == KSConSeConUid )
{
LOGGER_WRITE("Cannot uninstall itself, leave");
// cannot uninstall itself
User::Leave( SwiUI::KSWInstErrFileInUse );
}
Swi::RSisRegistrySession sisRegistry;
User::LeaveIfError( sisRegistry.Connect() );
CleanupClosePushL( sisRegistry );
//Check if uid belongs to SIS package
if( !sisRegistry.IsInstalledL( aUninstallParams.iUid ) )
{
CleanupStack::PopAndDestroy( &sisRegistry );
User::Leave( KErrNotFound );
}
Swi::RSisRegistryEntry entry;
CleanupClosePushL(entry);
User::LeaveIfError( entry.Open( sisRegistry, aUninstallParams.iUid ) );
if ( aUninstallParams.iType == ESisAugmentation )
{
// augmentation pkg
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL ESisAugmentation" );
TBool augmentationFound(EFalse);
// Get possible augmentations
RPointerArray<Swi::CSisRegistryPackage> augPackages;
CleanupResetAndDestroyPushL( augPackages );
entry.AugmentationsL( augPackages );
for ( TInt j( 0 ); j < augPackages.Count() && !augmentationFound; j++ )
{
Swi::RSisRegistryEntry augmentationEntry;
CleanupClosePushL( augmentationEntry );
augmentationEntry.OpenL( sisRegistry, *augPackages[j] );
HBufC* augPackageName = augmentationEntry.PackageNameL();
CleanupStack::PushL( augPackageName );
HBufC* augUniqueVendorName = augmentationEntry.UniqueVendorNameL();
CleanupStack::PushL( augUniqueVendorName );
if ( !augmentationEntry.IsInRomL()
&& augmentationEntry.IsPresentL()
&& aUninstallParams.iName.Compare( *augPackageName ) == 0
&& aUninstallParams.iVendor.Compare( *augUniqueVendorName ) == 0 )
{
// Correct augmentation found, uninstall it.
augmentationFound = ETrue;
TInt augmentationIndex = augPackages[j]->Index();
LOGGER_WRITE_1( "CSConAppInstaller::ProcessUninstallL augmentationIndex %d", augmentationIndex );
SwiUI::TOpUninstallIndexParam params;
params.iUid = aUninstallParams.iUid;
params.iIndex = augmentationIndex;
SwiUI::TOpUninstallIndexParamPckg pckg( params );
SwiUI::TOperation operation( SwiUI::EOperationUninstallIndex );
if( aUninstallParams.iMode == ESilentInstall )
{
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL : silent aug-sis-uninstall" );
SwiUI::TUninstallOptionsPckg options;
iInstallerState = ESilentCustomUnistalling;
iSWInst.SilentCustomUninstall( iStatus, operation, options, pckg, KSISMIMEType );
}
else
{
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL : unsilent aug-sis-uninstall" )
iInstallerState = ECustomUninstalling;
iSWInst.CustomUninstall( iStatus, operation, pckg, KSISMIMEType );
}
}
CleanupStack::PopAndDestroy( augUniqueVendorName );
CleanupStack::PopAndDestroy( augPackageName );
CleanupStack::PopAndDestroy( &augmentationEntry );
}
CleanupStack::PopAndDestroy( &augPackages );
if ( !augmentationFound )
{
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL augmentation not found -> Leave" );
User::Leave( KErrNotFound );
}
}
else
{
// Only uninstall if not in rom and is present
if ( !entry.IsInRomL() && entry.IsPresentL() )
{
if ( aUninstallParams.iMode == ESilentInstall )
{
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL : silent sis-uninstall" );
SwiUI::TUninstallOptionsPckg options;
iInstallerState = ESilentUninstalling;
iSWInst.SilentUninstall( iStatus, aUninstallParams.iUid, options, KSISMIMEType );
}
else
{
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL : unsilent sis-uninstall" )
iInstallerState = EUninstalling;
iSWInst.Uninstall( iStatus, aUninstallParams.iUid, KSISMIMEType );
}
}
else
{
LOGGER_WRITE( "CSConAppInstaller::ProcessUninstallL sis not present -> Leave" );
User::Leave( KErrNotFound );
}
}
CleanupStack::PopAndDestroy( &entry );
CleanupStack::PopAndDestroy( &sisRegistry );
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::UninstallJavaL( const TUid& aUid, const TSConInstallMode aMode )
// Uninstall java package
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::UninstallJavaL( const TUid& aUid, const TSConInstallMode aMode )
{
TRACE_FUNC_ENTRY;
CJavaRegistry* javaRegistry = CJavaRegistry::NewLC( );
TBool entryExist = javaRegistry->RegistryEntryExistsL( aUid );
CleanupStack::PopAndDestroy( javaRegistry );
if( entryExist )
{
if( aMode == ESilentInstall )
{
LOGGER_WRITE( "CSConAppInstaller::UninstallJavaL : silent midlet-uninstall" )
SwiUI::TUninstallOptionsPckg options;
iInstallerState = ESilentUninstalling;
iSWInst.SilentUninstall( iStatus, aUid, options, KMidletMIMEType );
}
else
{
LOGGER_WRITE( "CSConAppInstaller::UninstallJavaL : unsilent midlet-uninstall" )
iInstallerState = EUninstalling;
iSWInst.Uninstall( iStatus, aUid, KMidletMIMEType );
}
}
else
{
LOGGER_WRITE( "CSConAppInstaller::UninstallJavaL java entry does not exist -> Leave" )
User::Leave( KErrNotFound );
}
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::UninstallWidget( const TUid& aUid, const TSConInstallMode aMode )
// Uninstall widget
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::UninstallWidget( const TUid& aUid, const TSConInstallMode aMode )
{
TRACE_FUNC_ENTRY;
if( aMode == ESilentInstall )
{
LOGGER_WRITE( "CSConAppInstaller::UninstallWidget : silent uninstall" )
SwiUI::TUninstallOptionsPckg options;
iInstallerState = ESilentUninstalling;
iSWInst.SilentUninstall( iStatus, aUid, options, KWidgetMimeType );
}
else
{
LOGGER_WRITE( "CSConAppInstaller::UninstallWidget : unsilent uninstall" )
iInstallerState = EUninstalling;
iSWInst.Uninstall( iStatus, aUid, KWidgetMimeType );
}
TRACE_FUNC_EXIT;
}
//--------------------------------------------------------------------------------
//void CSConAppInstaller::ProcessListInstalledAppsL()
//--------------------------------------------------------------------------------
//
void CSConAppInstaller::ProcessListInstalledAppsL()
{
TRACE_FUNC_ENTRY;
CSConTask* task = NULL;
User::LeaveIfError( iQueue->GetTask( iCurrentTask, task ) );
SConPcdUtility::ProcessListInstalledAppsL( task );
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CSConAppInstaller::DeleteFile( const TDesC& aPath )
// Deletes a file
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::DeleteFile( const TDesC& aPath )
{
TRACE_FUNC;
iFs.Delete( aPath );
}
// End of file