FCL/sf/mw/appinstall: comparison appinstaller/AppinstUi/Daemon/Src/daemoninstaller.cpp

equal deleted inserted replaced

-:84a16765cd86
+:98b66e4fb0be
 /*
-* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2004-2010 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".
 *
 * Description:
 *
 */
+#include <usif/scr/scr.h>
+#include <usif/scr/screntries.h>
 #include "daemoninstaller.h"
 #include "DialogWrapper.h"
 #include "swispubsubdefs.h"
 // For uninstaller
 const static TInt KWaitUninstallerTime = 1000000; // 1 secs
 _LIT(KMCSisInstaller,"Daemon-Installer"); // Minor-Component name
+// -----------------------------------------------------------------------
 // Two phased construction
+// -----------------------------------------------------------------------
+//
 CSisInstaller* CSisInstaller::NewL(
 MDaemonInstallBehaviour* aDaemonBehaviour,
 CProgramStatus& aMainStatus)
 {
 CSisInstaller* self = new (ELeave) CSisInstaller( aDaemonBehaviour );
 self->ConstructL( aMainStatus ); // For uninstaller
 CleanupStack::Pop(self);
 return self;
 }
+// -----------------------------------------------------------------------
 // Install Request constructor
+// -----------------------------------------------------------------------
+//
 CSisInstaller::CSisInstaller( MDaemonInstallBehaviour* aDaemonBehaviour )
 : CActive(CActive::EPriorityStandard),
 iDaemonBehaviour( aDaemonBehaviour ),
 iState(EDSisInstallerStateIdle),
 iFileIndex(0),
 iInstallErr( KErrNone )
 {
 CActiveScheduler::Add(this);
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = EDSisInstallerStateIdle;
-iInstallerState = EDSisInstallerStateIdle;
+}
-#endif
-}
+// -----------------------------------------------------------------------
+// Destructor
-// Install Request destructor
+// -----------------------------------------------------------------------
+//
 CSisInstaller::~CSisInstaller()
 {
 Cancel();
 iTimer.Close();
 iFilesToInstall.ResetAndDestroy();
 delete iPreviouslyInstalledAppsCache;
 delete iInstallationFailedAppsCache;
 delete iShutdownWatcher;
 }
+// -----------------------------------------------------------------------
 // 2nd phase construction
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::ConstructL( CProgramStatus& aMainStatus )
 {
 User::LeaveIfError( iTimer.CreateLocal() );
 User::LeaveIfError( iFs.Connect() );
 User::LeaveIfError( iApaSession.Connect() );
 // SisInstaller do not own this so do not delete.
 iProgramStatus = &aMainStatus;
 iUpdateCache = ETrue;
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::AddFileToInstallL
 // Set the location of all sis files and the list of them
 // also take ownership of the pointers to memory
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::AddFileToInstallL(const TDesC& aFileName)
 {
 HBufC* fileName = aFileName.AllocLC();
 iFilesToInstall.AppendL( fileName );
 CleanupStack::Pop( fileName );
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::StartInstallingL
 // Start the request to process the Sisx file
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::StartInstallingL()
 {
 FLOG( _L("Daemon: StartInstallingL") );
 if(!iFilesToInstall.Count())
 }
 if ( iState == EDSisInstallerStateIdle )
 {
 // Reset the error
 iInstallErr = KErrNone;
+// Update cache so we do not try to start install for
+// components which are installed.
+FLOG( _L("Daemon: StartInstallingL: Update installed cache") );
+TRAP_IGNORE( iPreviouslyInstalledAppsCache->UpdateAllL() );
+TRAP_IGNORE( iPreviouslyInstalledAppsCache->FlushToDiskL() );
 CompleteSelf();
 }
 }
-#ifdef RD_MULTIPLE_DRIVE
+// -----------------------------------------------------------------------
+// CSisInstaller::IsInstalling
 // Returns state of Installer.
+// -----------------------------------------------------------------------
+//
 TBool CSisInstaller::IsInstalling()
 {
 if ( iInstallerState == EDSisInstallerStateCompleted )
 {
 return EFalse;
 else
 {
 return ETrue;
 }
 }
-#endif //RD_MULTIPLE_DRIVE
+// -----------------------------------------------------------------------
+// CSisInstaller::CompleteSelf
 // Complete the request manually
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::CompleteSelf()
 {
+FLOG( _L("Daemon: CSisInstaller::CompleteSelf") );
 if ( !IsActive() )
 {
 TRequestStatus* status = &iStatus;
 User::RequestComplete(status,KErrNone);
 SetActive();
 }
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::DoCancel
 // Cancel the active request
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::DoCancel()
 {
+FLOG( _L("Daemon: CSisInstaller::DoCancel") );
 iTimer.Cancel();
 iFileIndex = 0;
 iFilesToInstall.ResetAndDestroy();
 if ( iState == EDSisInstallerStateInstalling )
 FLOG( _L("Daemon: DoCancel: Set EStateIdle") );
 iProgramStatus->SetProgramStatusToIdle();
 }
 }
-// When the software installer has changed state
+// -----------------------------------------------------------------------
-// attemp to install a sisx file
+// CSisInstaller::RunL
+// When the software installer has changed state attemp to install a
+// sisx file
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::RunL()
 {
 FLOG_2( _L("Daemon: Installer RunL status:%d, state:%d"), iStatus.Int(), iState );
 // For uninstaller
 // If uninstaller is running already let's wait.
 FLOG( _L("Daemon: RunL: EStateUninstalling -> wait") );
 TTimeIntervalMicroSeconds32 time( KWaitUninstallerTime );
 iTimer.After(iStatus,time);
 // Set to idle, installer has not yet started.
 iState = EDSisInstallerStateIdle;
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = iState;
-iInstallerState = iState;
-#endif
 SetActive();
 }
 else
 {
 // Ok uninstaller is in idle, run installing.
 {
 FLOG( _L("Daemon: RunL: iStatus: KSWInstErrBusy") );
 // User might be installing something, wait before retrying
 TTimeIntervalMicroSeconds32 time( KInstallRetryWaitTime );
 iTimer.After(iStatus,time);
 iState = EDSisInstallerStateInstallerBusy;
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = iState;
-iInstallerState = iState;
-#endif
 SetActive();
 break;
 }
 else if ( (iStatus.Int() == SwiUI::KSWInstErrSecurityFailure && iInstallErr == KErrNone) ||
 (iStatus.Int() != KErrNone && iStatus.Int() != SwiUI::KSWInstErrSecurityFailure) )
 // Check if we have more to install
 if ( iFileIndex < iFilesToInstall.Count() )
 {
 // Kick of the next installation
 iState = EDSisInstallerStateIdle;
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = iState;
-iInstallerState = iState;
-#endif
 CompleteSelf();
 }
 else
 {
 // Note that this will also signal plugin that
 TRAP_IGNORE( iDaemonBehaviour->RequestPluginInstall( iSisFile ) );
 // Let's continue to give all packages to plug-in.
 // Note that we do not have iStatus as this is not async. call
 // so we can not use EDSisInstallerStateInstalling state.
 iState = EDSisInstallerStateIdle;
-#ifdef RD_MULTIPLE_DRIVE
 iInstallerState = iState;
-#endif
 // Plugin interface is not asyncronous. We need to
 // complete self to get all packages to plugin.
 CompleteSelf();
 }
 else
 {
 FLOG_1( _L("Daemon: Kick off the install for %S"), &iSisFile );
 iInstallLauncher->InstallL( iSisFile, iStatus );
 iDialogs->ShowWaitingNoteL();
 iState = EDSisInstallerStateInstalling;
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = iState;
-iInstallerState = iState;
-#endif
 SetActive();
 }
 }
 else
 {
 FLOG_1( _L("Daemon: No need to install %S"), &iSisFile );
 iState = EDSisInstallerStateIdle;
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = iState;
-iInstallerState = iState;
-#endif
 // Clear current pkg UID
 iCurrentPackageId = TUid::Null();
 CompleteSelf();
 }
 case EDSisInstallerStateInstallerBusy:
 // Try to install the file again
 FLOG( _L("Daemon: RunL: EDSisInstallerStateInstallerBusy") );
 FLOG_1( _L("Daemon: Kick off the install for %S"), &iSisFile );
 iInstallLauncher->InstallL( iSisFile, iStatus );
 iState = EDSisInstallerStateInstalling;
-#ifdef RD_MULTIPLE_DRIVE
+iInstallerState = iState;
-iInstallerState = iState;
-#endif
 SetActive();
 break;
 // Active object in unknown state
 default:
 User::Panic(KMCSisInstaller,KErrNotSupported);
 break;
 }
 } // else for uninstaller
-}
+FLOG( _L("Daemon: RunL END") );
+}
+// -----------------------------------------------------------------------
+// CSisInstaller::RunError
 // If RunL leaves then ignore errors
+// -----------------------------------------------------------------------
+//
 TInt CSisInstaller::RunError(TInt aError)
 {
-FLOG_1( _L("Daemon: Installer RunL error %d"), aError );
+FLOG_1( _L("Daemon: Installer Run error %d"), aError );
 TInt err( KErrNone );
 InstallationCompleted( aError );
 return err;
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::NotifyShuttingDown
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::NotifyShuttingDown()
 {
 // System is closing down, we need to stop installations and save
 // the lists of previously installed apps and failed installations.
 // Application server receives EApaSystemEventShutdown event that
 // closes it down.
 Cancel();
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::InstallationCompleted
+// -----------------------------------------------------------------------
+//
 void CSisInstaller::InstallationCompleted( TInt aResult )
 {
 FLOG_1( _L("Daemon: InstallationCompleted with result = %d"), aResult );
 iState = EDSisInstallerStateIdle;
 iInstallErr = KErrNone;
 iInstallLauncher = NULL;
 // We need to update cache again in RunL if plug-in is loaded.
 // It may be that plug-in does install packages after cache is updated.
 iUpdateCache = ETrue;
-#ifdef RD_MULTIPLE_DRIVE
 // If all files are installed set status to completed.
 if ( iFileIndex >= iFilesToInstall.Count() )
 {
 iInstallerState = EDSisInstallerStateCompleted;
 }
-#endif
 TRAP_IGNORE( iDialogs->CancelWaitingNoteL() );
 if ( aResult != KErrNone &&
 iSisFile.Length() > 0 &&
 IsMediaPresent( TChar( iSisFile[0] ) ) )
 else
 {
 TRAP_IGNORE( iDialogs->ShowErrorResultL() );
 }
 }
-FLOG( _L("Daemon: InstallationCompleted: Update installed cache") );
+//TODO: remove this update. This is done in start installing !!!!
+//FLOG( _L("Daemon: InstallationCompleted: Update installed cache") );
 // Update cache so we do not start to install those packages
 // which are installed by the user manyally.
 // NOTE! plugin will install stuff after this call.
-TRAP_IGNORE(iPreviouslyInstalledAppsCache->UpdateAllL());
+//TRAP_IGNORE(iPreviouslyInstalledAppsCache->UpdateAllL());
 TRAP_IGNORE(iPreviouslyInstalledAppsCache->FlushToDiskL(););
 TRAP_IGNORE(iInstallationFailedAppsCache->FlushToDiskL());
 // Notify plugin that daemon has complete installation.
 FLOG( _L("Daemon: InstallationCompleted: Set EStateIdle") );
 iProgramStatus->SetProgramStatusToIdle();
 }
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::NeedsInstallingL
 // Indicates if this package is installed or not.
+// -----------------------------------------------------------------------
+//
 TBool CSisInstaller::NeedsInstallingL( const TDesC& aPackageName )
 {
-FLOG( _L("Daemon: NeedsInstallingL") );
+FLOG( _L("Daemon: CSisInstaller::NeedsInstallingL") );
-TBool result( ETrue );
+//TBool result( ETrue );
+TBool needsInstalling( ETrue );
 // Read the controller data from the package
 CFileSisDataProvider* fileProvider = CFileSisDataProvider::NewLC( iFs, aPackageName );
 TInt64 pos( 0 );
 fileProvider->Seek( ESeekStart, pos );
 HBufC8* controller = content->ReadControllerL();
 CleanupStack::PushL( controller );
 // Code to read UID
 	CDesDataProvider* controllerProvider= CDesDataProvider::NewLC(*controller);
 	CController* controllerObject = NULL;
 	controllerObject = CController::NewL(*controllerProvider);
 	CleanupStack::PushL(controllerObject);
 	TUid packageId = controllerObject->Info().Uid().Uid();
-	CleanupStack::PopAndDestroy(controllerObject);
+	CleanupStack::PopAndDestroy( controllerObject );
-	CleanupStack::PopAndDestroy(controllerProvider);
+	CleanupStack::PopAndDestroy( controllerProvider );
-	FLOG_1( _L("Daemon: NeedsInstallingL: Is UID installed = 0x%x"), packageId.iUid );
+	// Check if sw is installed previously.
-	result = !iPreviouslyInstalledAppsCache->HasBeenPreviouslyInstalled(packageId);
+	// Note if UID is found sw will not be installed even if user
-	FLOG_1( _L("Daemon: NeedsInstallingL: Has been installed (cache) = %d"), !result );
+	// has uninstall it bacause cache is not updated from SCR.
+	FLOG_1( _L("Daemon: Is UID installed = 0x%x"), packageId.iUid );
-	if (result)
+	needsInstalling = !iPreviouslyInstalledAppsCache->
-	    {
+HasBeenPreviouslyInstalled(packageId);
+	FLOG_1( _L("Daemon: Has been installed (cache) = %d"), !needsInstalling );
+// TODO: Onko rom stubien tarkistus tarpeen jos upgrade ei ole sallittu.
+// Ei taida kannattaa tarksitaan RU ei pitäisi mennä läpi.
+	FLOG( _L("Daemon: HUOM ROM STUBEJA EI TARKISTETA") );
+	/*
+	// Huom! edellinen koodi ollut väärin koska UID on jo cachessä !
+	// Tarkistus pitää tehdä vain jos UID löytyy cachestä.
+	if ( !needsInstalling )
+{
 RSisRegistrySession registry;
 User::LeaveIfError( registry.Connect() );
 CleanupClosePushL( registry );
 result = !registry.IsInstalledL( packageId );
 {
 RSisRegistryEntry entry;
 User::LeaveIfError( entry.Open( registry, packageId ) );
 CleanupClosePushL( entry );
-result = entry.IsInRomL();
+needsInstalling = entry.IsInRomL();
-FLOG_1( _L("Daemon: NeedsInstallingL: Is in ROM = %d"), result );
+FLOG_1( _L("Daemon: NeedsInstallingL: Is in ROM = %d"), needsInstalling );
 CleanupStack::PopAndDestroy( &entry );
 }
 CleanupStack::PopAndDestroy( &registry );
-		}
+}
+	*/
 // Check that previous install attempt did not fail.
-	if (result)
+	if ( needsInstalling )
 	    {
-	    result = !iInstallationFailedAppsCache->HasPreviousInstallationFailed( packageId );
+	    needsInstalling = !iInstallationFailedAppsCache->
-	    FLOG_1( _L("Daemon: NeedsInstallingL: Has failed (cache) = %d"), !result );
+	            HasPreviousInstallationFailed( packageId );
+	    FLOG_1( _L("Daemon: Has failed (cache) = %d"), !needsInstalling );
 	    }
 // Update pkg ID. ID is added to cache after installation.
-if (result)
+if ( needsInstalling )
 {
 iCurrentPackageId = packageId;
 }
+// fileProvider, content, controller
 CleanupStack::PopAndDestroy( 3 );
-return result;
+FLOG_1( _L("Daemon: NeedsInstallingL = %d"), needsInstalling );
+return needsInstalling;
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::IsMediaPresent
+// -----------------------------------------------------------------------
+//
 TBool CSisInstaller::IsMediaPresent( TChar aDrive )
 {
 TInt drive( 0 );
 TInt err = iFs.CharToDrive( aDrive, drive );
 if ( err == KErrNone )
 FLOG( _L("Daemon: Drive no present") );
 return EFalse;
 }
 }
+// -----------------------------------------------------------------------
+// CSisInstaller::IsValidPackageL
+// -----------------------------------------------------------------------
+//
 TBool CSisInstaller::IsValidPackageL( const TDesC& aPackageName )
 {
 TBool result( EFalse );
 RFile file;
 if ( dataType.Des8() == SwiUI::KSisxMimeType )
 {
 result = ETrue;
 }
+FLOG_1( _L("Daemon: IsValidPackageL = %d"), result );
 return result;
 }
 //EOF

changeset 25	98b66e4fb0be
parent 0	ba25891c3a9e
child 29	26b6f0522fd8