FCL/sf/mw/appinstall: comparison appinstaller/AppinstUi/sisxsifplugin/src/sisxsifpluginactiveimpl.cpp

equal deleted inserted replaced

-:98b66e4fb0be
+:26b6f0522fd8
 *
 */
 #include "sisxsifpluginactiveimpl.h"    // CSisxSifPluginActiveImpl
 #include "sisxsifpluginuihandler.h"     // CSisxSifPluginUiHandler
+#include "sisxsifpluginuihandlersilent.h" // CSisxSifPluginUiHandlerSilent
 #include "sisxsifcleanuputils.h"        // CleanupResetAndDestroyPushL
 #include "sisxsifplugin.pan"            // Panic codes
 #include <usif/sif/sifcommon.h>         // Usif::CComponentInfo
 #include <usif/scr/scr.h>               // RSoftwareComponentRegistry
 #include <usif/usiferror.h>             // SIF error codes
 	{
 	FLOG( _L("Destructing CSisxSifPluginActiveImpl") );
 	Cancel();
 delete iAsyncLauncher;
 delete iUiHandler;
+delete iUiHandlerSilent;
 delete iInstallPrefs;
 delete iComponentInfo;
 delete iFileName;
 iFs.Close();
 	}
 // CSisxSifPluginActiveImpl::DoCancel()
 // ---------------------------------------------------------------------------
 //
 void CSisxSifPluginActiveImpl::DoCancel()
 {
+FLOG( _L("CSisxSifPluginActiveImpl::DoCancel") );
 if( iClientStatus )
 {
 if( iAsyncLauncher )
 {
 iAsyncLauncher->CancelOperation();
 delete iAsyncLauncher;
 iAsyncLauncher = NULL;
 }
-User::RequestComplete( iClientStatus, KErrCancel );
+CompleteClientRequest( KErrCancel );
-iClientStatus = NULL;
 }
 }
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::RunL()
 // ---------------------------------------------------------------------------
 //
 void CSisxSifPluginActiveImpl::RunL()
 {
 TInt result = iStatus.Int();
-FLOG_1( _L("CSisxSifPluginActiveImpl::RunL(), result %d"), result );
+FLOG_2( _L("CSisxSifPluginActiveImpl::RunL(), op %d, result %d"), iOperation, result );
-if( iSilentInstall )
+if( result == KErrNone && iOperation == EInstall &&
-{
+iUseSilentMode && !iIsPackageCheckedForSilentInstall )
-FLOG( _L("CSisxSifPluginActiveImpl::RunL, silent install") );
+{
-ProcessSilentInstallL();
+ProcessSilentInstallL();    // makes the real silent install request
+iIsPackageCheckedForSilentInstall = ETrue;
 }
 else
 {
 if( iOutputParams )
 {
 iOutputParams->AddIntL( KSifOutParam_ExtendedErrCode, result );
-if( iInstallRequest && result == KErrNone )
+if( iOperation == EInstall && result == KErrNone )
 {
 TComponentId resultComponentId = 0;
 TRAPD( getLastIdErr, resultComponentId = GetLastInstalledComponentIdL() );
 if( getLastIdErr == KErrNone )
 {
 }
 }
 }
 TInt errorCode = ConvertToSifErrorCode( result );
-if( !iSilentInstall )
+if( !iUseSilentMode )
 {
 if( errorCode == KErrNone )
 {
 iUiHandler->DisplayCompleteL();
 }
 const TDesC& aFileName,
 const TSecurityContext& /*aSecurityContext*/,
 CComponentInfo& aComponentInfo,
 TRequestStatus& aStatus )
 	{
+iOperation = EGetComponentInfo;
 aStatus = KRequestPending;
 iClientStatus = &aStatus;
-TRAPD( err, iAsyncLauncher->GetComponentInfoL( *iUiHandler, aFileName,
+TRAPD( err, iAsyncLauncher->GetComponentInfoL( UiHandlerL(), aFileName,
 *iInstallPrefs, aComponentInfo, iStatus ) );
 FLOG_1( _L("CSisxSifPluginActiveImpl::GetComponentInfo, err = %d"), err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 SetActive();
 	}
 RFile& aFileHandle,
 const TSecurityContext& /*aSecurityContext*/,
 CComponentInfo& aComponentInfo,
 TRequestStatus& aStatus )
 	{
+iOperation = EGetComponentInfo;
 aStatus = KRequestPending;
 iClientStatus = &aStatus;
-TRAPD( err, iAsyncLauncher->GetComponentInfoL( *iUiHandler, aFileHandle,
+TRAPD( err, iAsyncLauncher->GetComponentInfoL( UiHandlerL(), aFileHandle,
 *iInstallPrefs, aComponentInfo, iStatus ) );
 FLOG_1( _L("CSisxSifPluginActiveImpl::GetComponentInfo, err = %d"), err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 SetActive();
 	}
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::Install()
 const TSecurityContext& aSecurityContext,
 const COpaqueNamedParams& aInputParams,
 COpaqueNamedParams& aOutputParams,
 TRequestStatus& aStatus )
 	{
-CommonRequestPreamble( aSecurityContext, aInputParams, aOutputParams, aStatus );
+iOperation = EInstall;
+CommonRequestPreamble( aInputParams, aOutputParams, aStatus );
-FLOG_2( _L("CSisxSifPluginActiveImpl::Install: %S, iSilentInstall=%d"),
-&aFileName, iSilentInstall );
+if( iUseSilentMode && !aSecurityContext.HasCapability( ECapabilityTrustedUI ) )
+{
+FLOG( _L("CSisxSifPluginActiveImpl: missing ECapabilityTrustedUI ERROR") );
+CompleteClientRequest( KErrPermissionDenied );
+return;
+}
+FLOG_2( _L("CSisxSifPluginActiveImpl::Install: %S, iUseSilentMode=%d"),
+&aFileName, iUseSilentMode );
 TRAPD( err, DoInstallL( aFileName ) );
-FLOG_2( _L("CSisxSifPluginActiveImpl::Install, iInstallRequest=%d, err=%d"),
+FLOG_1( _L("CSisxSifPluginActiveImpl::Install, err=%d"), err );
-iInstallRequest, err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 SetActive();
 	}
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::Install()
 const TSecurityContext& aSecurityContext,
 const COpaqueNamedParams& aInputParams,
 COpaqueNamedParams& aOutputParams,
 TRequestStatus& aStatus )
 	{
-CommonRequestPreamble( aSecurityContext, aInputParams, aOutputParams, aStatus );
+iOperation = EInstall;
+CommonRequestPreamble( aInputParams, aOutputParams, aStatus );
-FLOG_1( _L("CSisxSifPluginActiveImpl::Install, iSilentInstall=%d"), iSilentInstall );
+if( iUseSilentMode && !aSecurityContext.HasCapability( ECapabilityTrustedUI ) )
-TInt err;
+{
-if( iSilentInstall )
+FLOG( _L("CSisxSifPluginActiveImpl: missing ECapabilityTrustedUI ERROR") );
+CompleteClientRequest( KErrPermissionDenied );
+return;
+}
+FLOG_1( _L("CSisxSifPluginActiveImpl::Install, iUseSilentMode=%d"), iUseSilentMode );
+TInt err = KErrNone;
+if( iUseSilentMode )
 {
 // Silent install does a few addtional checks on the package to see if is
 // signed and had the required capabilities. So we need to the get the
 // package component information without installing it. Real silent install
 // operation is started in RunL() after this GetComponentInfoL() completes.
 SetSilentInstallFile( aFileHandle );
-TRAP( err, iAsyncLauncher->GetComponentInfoL( *iUiHandler, aFileHandle, *iInstallPrefs,
+TRAP( err, iAsyncLauncher->GetComponentInfoL( UiHandlerL( iUseSilentMode ),
-*iComponentInfo, iStatus ) );
+aFileHandle, *iInstallPrefs, *iComponentInfo, iStatus ) );
+FLOG_1( _L("CSisxSifPluginActiveImpl::GetComponentInfoL, err=%d"), err );
 }
 else
 {
 // Proceed with the normal installation.
-TRAP( err, iAsyncLauncher->InstallL( *iUiHandler, aFileHandle, *iInstallPrefs, iStatus ) );
+TRAP( err, iAsyncLauncher->InstallL( UiHandlerL(), aFileHandle,
-iInstallRequest = ETrue;
+*iInstallPrefs, iStatus ) );
-}
+FLOG_1( _L("CSisxSifPluginActiveImpl::Install, err=%d"), err );
+}
-FLOG_2( _L("CSisxSifPluginActiveImpl::Install, iInstallRequest=%d, err=%d"),
-iInstallRequest, err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 SetActive();
 	}
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::Uninstall()
 const TSecurityContext& aSecurityContext,
 const COpaqueNamedParams& aInputParams,
 COpaqueNamedParams& aOutputParams,
 TRequestStatus& aStatus )
 	{
-CommonRequestPreamble( aSecurityContext, aInputParams, aOutputParams, aStatus );
+iOperation = EUninstall;
+CommonRequestPreamble( aInputParams, aOutputParams, aStatus );
-TRAPD( err, DoUninstallL( aComponentId, aStatus ) );
+// Uninstall is always silent. TrustedUI capability is always required.
+if( !aSecurityContext.HasCapability( ECapabilityTrustedUI ) )
+{
+FLOG( _L( "CSisxSifPluginActiveImpl: missing ECapabilityTrustedUI ERROR") );
+CompleteClientRequest( KErrPermissionDenied );
+return;
+}
+iUseSilentMode = ETrue;     // no complete/error notes launched in RunL
+FLOG( _L("CSisxSifPluginActiveImpl::Uninstall") );
+TRAPD( err, DoUninstallL( aComponentId ) );
 FLOG_1( _L("CSisxSifPluginActiveImpl::Uninstall, err=%d"), err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 SetActive();
 	}
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::Activate()
 void CSisxSifPluginActiveImpl::Activate(
 TComponentId aComponentId,
 const TSecurityContext& /*aSecurityContext*/,
 TRequestStatus& aStatus )
 	{
+iOperation = EActivate;
 aStatus = KRequestPending;
 iClientStatus = &aStatus;
 TRAPD( err, DoActivateL( aComponentId ) );
 FLOG_2( _L("CSisxSifPluginActiveImpl::Activate, component %d, err=%d"), aComponentId, err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 iStatus = KRequestPending;
-CompleteRequest( iStatus, KErrNone );
+TRequestStatus* status = &iStatus;
+User::RequestComplete( status, KErrNone );
 SetActive();
 	}
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::Deactivate()
 void CSisxSifPluginActiveImpl::Deactivate(
 TComponentId aComponentId,
 const TSecurityContext& /*aSecurityContext*/,
 TRequestStatus& aStatus )
 	{
+iOperation = EDeactivate;
 aStatus = KRequestPending;
 iClientStatus = &aStatus;
-Swi::RSisRegistryWritableSession sisRegSession;
 TRAPD( err, DoDeactivateL( aComponentId ) );
 FLOG_2( _L("CSisxSifPluginActiveImpl::Deactivate, component %d, err=%d"), aComponentId, err );
 if( err != KErrNone )
 {
-CompleteRequest( aStatus, err );
+CompleteClientRequest( err );
 return;
 }
 iStatus = KRequestPending;
-CompleteRequest( iStatus, KErrNone );
+TRequestStatus* status = &iStatus;
+User::RequestComplete( status, KErrNone );
 SetActive();
 	}
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::CSisxSifPluginActiveImpl()
 //
 void CSisxSifPluginActiveImpl::ConstructL()
 {
 User::LeaveIfError( iFs.Connect() );
-iUiHandler = CSisxSifPluginUiHandler::NewL( iFs );
 iAsyncLauncher = Swi::CAsyncLauncher::NewL();
 iInstallPrefs = Swi::CInstallPrefs::NewL();
 iComponentInfo = CComponentInfo::NewL();
 }
 // ---------------------------------------------------------------------------
-// CSisxSifPluginActiveImpl::Complete()
+// CSisxSifPluginActiveImpl::UiHandlerL()
 // ---------------------------------------------------------------------------
 //
-void CSisxSifPluginActiveImpl::CompleteRequest( TRequestStatus& aStatus, TInt aResult )
+Swi::MUiHandler& CSisxSifPluginActiveImpl::UiHandlerL( TBool aUseSilentMode )
 {
-TRequestStatus* statusPtr = &aStatus;
+Swi::MUiHandler* handler = NULL;
-User::RequestComplete( statusPtr, aResult );
+if( aUseSilentMode )
+{
+if( iUiHandler )
+{
+delete iUiHandler;
+iUiHandler = NULL;
+}
+if( !iUiHandlerSilent )
+{
+iUiHandlerSilent = CSisxSifPluginUiHandlerSilent::NewL( iFs );
+}
+handler = iUiHandlerSilent;
+}
+else
+{
+if( iUiHandlerSilent )
+{
+delete iUiHandlerSilent;
+iUiHandlerSilent = NULL;
+}
+if( !iUiHandler )
+{
+iUiHandler = CSisxSifPluginUiHandler::NewL( iFs );
+}
+handler = iUiHandler;
+}
+return *handler;
 }
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::CommonRequestPreamble()
 // ---------------------------------------------------------------------------
 //
 void CSisxSifPluginActiveImpl::CommonRequestPreamble(
-const TSecurityContext& aSecurityContext,
 const COpaqueNamedParams& aInputParams,
 COpaqueNamedParams& aOutputParams,
 TRequestStatus& aStatus )
 {
 aStatus = KRequestPending;
 iClientStatus = &aStatus;
+TInt silentInstall = 0;
+TRAPD( err, aInputParams.GetIntByNameL( KSifInParam_InstallSilently, silentInstall ) );
+iUseSilentMode = ( err == KErrNone && silentInstall != 0 );
+iIsPackageCheckedForSilentInstall = EFalse;
 iInputParams = &aInputParams;
 iOutputParams = &aOutputParams;
-// Check InstallSilently opaque input argument
-TInt silentInstall = 0;
-TRAP_IGNORE( aInputParams.GetIntByNameL( KSifInParam_InstallSilently, silentInstall ) );
-if( silentInstall )
-{
-iSilentInstall = ETrue;
-if( !aSecurityContext.HasCapability( ECapabilityTrustedUI ) )
-{
-FLOG( _L("CSisxSifPluginActiveImpl: missing ECapabilityTrustedUI ERROR") );
-CompleteRequest( aStatus, KErrPermissionDenied );
-iClientStatus = NULL;
-}
-}
 // TODO: KSifInParam_InstallInactive
 }
 // ---------------------------------------------------------------------------
+// CSisxSifPluginActiveImpl::CompleteClientRequest()
+// ---------------------------------------------------------------------------
+//
+void CSisxSifPluginActiveImpl::CompleteClientRequest( TInt aResult )
+{
+if( iClientStatus )
+{
+User::RequestComplete( iClientStatus, aResult );
+iClientStatus = NULL;
+}
+}
+// ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::DoInstallL()
 // ---------------------------------------------------------------------------
 //
 void CSisxSifPluginActiveImpl::DoInstallL( const TDesC& aFileName )
 {
-if( iSilentInstall )
+if( iUseSilentMode )
 {
 // Silent install does a few addtional checks on the package to see if is
 // signed and had the required capabilities. So we need to the get the
 // package component information without installing it. Real silent install
 // operation is started in RunL() after this GetComponentInfoL() completes.
 SetSilentInstallFileL( aFileName );
-iAsyncLauncher->GetComponentInfoL( *iUiHandler, aFileName, *iInstallPrefs,
+iIsPackageCheckedForSilentInstall = EFalse;
-*iComponentInfo, iStatus );
+iAsyncLauncher->GetComponentInfoL( UiHandlerL( iUseSilentMode ), aFileName,
+*iInstallPrefs, *iComponentInfo, iStatus );
 }
 else
 {
 // Proceed with the normal installation.
-iAsyncLauncher->InstallL( *iUiHandler, aFileName, *iInstallPrefs, iStatus );
+iAsyncLauncher->InstallL( UiHandlerL(), aFileName, *iInstallPrefs, iStatus );
-iInstallRequest = ETrue;
 }
 }
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::DoUninstallL()
 // ---------------------------------------------------------------------------
 //
-void CSisxSifPluginActiveImpl::DoUninstallL( TComponentId aComponentId, TRequestStatus& /*aStatus*/ )
+void CSisxSifPluginActiveImpl::DoUninstallL( TComponentId aComponentId )
 {
 RSoftwareComponentRegistry scrSession;
 User::LeaveIfError( scrSession.Connect() );
 CleanupClosePushL( scrSession );
 }
 TUid objectId = TUid::Uid( intPropertyEntry->IntValue() );
 CleanupStack::PopAndDestroy( 2, &scrSession );      // propertyEntry, scrSession
-iAsyncLauncher->UninstallL( *iUiHandler, objectId, iStatus );
+iAsyncLauncher->UninstallL( UiHandlerL( iUseSilentMode ), objectId, iStatus );
 }
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::DoActivateL()
 // ---------------------------------------------------------------------------
 // CSisxSifPluginActiveImpl::ConvertToSifErrorCode()
 // ---------------------------------------------------------------------------
 //
 TInt CSisxSifPluginActiveImpl::ConvertToSifErrorCode( TInt aSwiErrorCode )
 {
+FLOG_1( _L("CSisxSifPluginActiveImpl::ConvertToSifErrorCode(), aSwiErrorCode=%d"),
+aSwiErrorCode );
 // TODO: need to show also SWI error code in UI somehow when necessary
 if( aSwiErrorCode > KSystemWideErrorsBoundary )
 {
 return aSwiErrorCode;
 // CSisxSifPluginActiveImpl::GetLastInstalledComponentIdL()
 // ---------------------------------------------------------------------------
 //
 TComponentId CSisxSifPluginActiveImpl::GetLastInstalledComponentIdL()
 {
-ASSERT( iInstallRequest );
+ASSERT( iOperation == EInstall );
 // Find the id of the last installed component and return it
 TInt uid;
 User::LeaveIfError( RProperty::Get( KUidSystemCategory, KUidSwiLatestInstallation, uid ) );
 return componentId;
 }
 // ---------------------------------------------------------------------------
-// CSisxSifPluginActiveImpl::NeedUserCapabilityL()
+// CSisxSifPluginActiveImpl::RequiresUserCapabilityL()
 // ---------------------------------------------------------------------------
 //
-TBool CSisxSifPluginActiveImpl::NeedUserCapabilityL()
+TBool CSisxSifPluginActiveImpl::RequiresUserCapabilityL()
 {
 // Silent install is not allowed when the package requires additional capabilities
 // than what it is signed for (Package may request for some capability that is not
 // granted by the certificate used to sign it).
 const TCapabilitySet& componentUserCaps( iComponentInfo->RootNodeL().UserGrantableCaps() );
 // CSisxSifPluginActiveImpl::ProcessSilentInstallL()
 // ---------------------------------------------------------------------------
 //
 void CSisxSifPluginActiveImpl::ProcessSilentInstallL()
 {
-// We need to do this only once per installation request
+TBool isAuthenticated = ( iComponentInfo->RootNodeL().Authenticity() == EAuthenticated );
-iSilentInstall = EFalse;
+TBool requiresUserCapability = RequiresUserCapabilityL();
-iInstallRequest = ETrue;
+if( !isAuthenticated || requiresUserCapability )
+{
-// TODO: should self-signed packages that do not contain executables be allowed?
+if( !isAuthenticated )
-//TBool hasExecutable = iComponentInfo->RootNodeL().HasExecutable();
-TBool isNotAuthenticated = ( iComponentInfo->RootNodeL().Authenticity() == ENotAuthenticated );
-TBool reqUserCap = NeedUserCapabilityL();
-if( isNotAuthenticated || reqUserCap )
-{
-if( isNotAuthenticated )
 {
 FLOG( _L("Silent Install is not allowed on unsigned or self-signed packages") );
 }
-if( reqUserCap )
+if( requiresUserCapability )
 {
 FLOG( _L("Silent Install is not allowed when user capabilities are required") );
 }
-User::RequestComplete( iClientStatus, KErrPermissionDenied );
+CompleteClientRequest( KErrPermissionDenied );
-iClientStatus = NULL;
 }
 else
 {
 TInt err = KErrNone;
 if( iFileHandle )
 {
-TRAP( err, iAsyncLauncher->InstallL( *iUiHandler, *iFileHandle, *iInstallPrefs, iStatus ) );
+TRAP( err, iAsyncLauncher->InstallL( UiHandlerL( iUseSilentMode ), *iFileHandle,
+*iInstallPrefs, iStatus ) );
 }
 else if( iFileName )
 {
-TRAP( err, iAsyncLauncher->InstallL( *iUiHandler, *iFileName, *iInstallPrefs, iStatus ) );
+TRAP( err, iAsyncLauncher->InstallL( UiHandlerL( iUseSilentMode ), *iFileName,
+*iInstallPrefs, iStatus ) );
 }
 else
 {
 Panic( ESisxSifInternalError );
 }
 {
 SetActive();
 }
 else
 {
-User::RequestComplete( iClientStatus, err );
+CompleteClientRequest( err );
-iClientStatus = NULL;
 }
 }
 }
 // ---------------------------------------------------------------------------

changeset 29	26b6f0522fd8
parent 25	98b66e4fb0be
child 33	8110bf1194d1