1 /*

     2 * Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *     State machine implementation

    16 *

    17 *

    18 */

    19 

    20 

    21 #include <ADM.rsg>

    22 #include "ADMApplication.h" // KUidADMApp

    23 #include "ADMStateMachine.h"

    24 #include "ADMStateMachineDebug.h"

    25 #include "globals.h"

    26 #include "config.h"

    27 

    28 #include <e32std.h>

    29 #include <sysutil.h>        // SysUtil::DiskSpaceBelowCriticalLevel()

    30 #include <BAUTILS.H>

    31 #include <apgcli.h>

    32 

    33 // Use Char 0xFF to indicate no drive is selected

    34 const TChar KNoDriveSelected = 0xFF;

    35 

    36 // Used to force the progress bar to finish

    37 const TInt KProgressBarFullValue = 100;

    38 

    39 TInt CompareVersions(TVersion& version1, TVersion& version2);

    40 

    41 // ---------------------------------------------------------------------------

    42 // Panic

    43 //

    44 // Raises a panic with specific panic code.

    45 // ---------------------------------------------------------------------------

    46 //

    47 LOCAL_C inline void Panic(TInt aPanicCode)

    48 	{

    49 	_LIT(KPanic, "SmartInst-SM");

    50 	User::Panic( KPanic, aPanicCode );

    51 	}

    52 

    53 LOCAL_C inline void Panic(TInt aPanicCode, TInt aState)

    54 	{

    55 	_LIT(KPanic, "SmartInst-SM");

    56 	const TInt reason = aState*100 + aPanicCode;

    57 	User::Panic( KPanic, reason );

    58 	}

    59 

    60 // -----------------------------------------------------------------------------

    61 // Default constructor

    62 // -----------------------------------------------------------------------------

    63 //

    64 CStateMachine::CStateMachine(CADMAppUi& aAppUi) :

    65 	CActive(EPriorityNormal),

    66 	iAppUi(aAppUi),

    67 	iFailedState( CStateFactory::EStateLast )

    68 	{

    69 	CActiveScheduler::Add(this);

    70 	}

    71 

    72 // -----------------------------------------------------------------------------

    73 // NewL()

    74 // -----------------------------------------------------------------------------

    75 //

    76 CStateMachine* CStateMachine::NewL(CADMAppUi& aAppUi, const TDesC& aDownloadPath)

    77 	{

    78 	CStateMachine* self = new (ELeave) CStateMachine(aAppUi);

    79 	CleanupStack::PushL(self);

    80 	self->ConstructL(aDownloadPath);

    81 	CleanupStack::Pop();

    82 	return self;

    83 	}

    84 

    85 // -----------------------------------------------------------------------------

    86 // ConstructL()

    87 // -----------------------------------------------------------------------------

    88 //

    89 void CStateMachine::ConstructL(const TDesC& aDownloadPath)

    90 	{

    91 	// Create a local semaphore for handling the download deleting

    92 	// This must be the first to be created and last to be destroyed.

    93 	iDlDeletingSemaphore.CreateLocal(0);

    94 

    95 	iXmlParser = CXmlParser::NewL();

    96 	iSisParser = CSisParser::NewL();

    97 

    98 #ifdef USE_LOGFILE

    99 	iInstallManager = CInstallManager::NewL(this, iAppUi.iLog);

   100 	iDepTree = CDepTree::NewL(iAppUi.iLog, aDownloadPath);

   101 	iDownloadHandler = CDownloadHandler::NewL(this, iAppUi.iLog, !(iAppUi.EikonEnv()->StartedAsServerApp()));

   102 #else

   103 	iInstallManager = CInstallManager::NewL(this);

   104 	iDepTree = CDepTree::NewL(aDownloadPath);

   105 	iDownloadHandler = CDownloadHandler::NewL(this, !(iAppUi.EikonEnv()->StartedAsServerApp()));

   106 #endif

   107 

   108 	iStateFactory = CStateFactory::NewL(*this);

   109 	}

   110 

   111 // -----------------------------------------------------------------------------

   112 // Destructor

   113 // -----------------------------------------------------------------------------

   114 //

   115 CStateMachine::~CStateMachine()

   116 	{

   117 	if (IsActive())

   118 		{

   119 		Cancel();

   120 		}

   121 	delete iStateFactory;

   122 	delete iDownloadHandler;

   123 	delete iInstallManager;

   124 	delete iDepTree;

   125 	delete iSisParser;

   126 	delete iXmlParser;

   127 	delete iDownloadedFile;

   128 

   129 	iDlDeletingSemaphore.Close();

   130 	}

   131 

   132 // -----------------------------------------------------------------------------

   133 // Updates the displayed progress bar

   134 // -----------------------------------------------------------------------------

   135 //

   136 void CStateMachine::UpdateProgressBar(TInt aStartValue, TInt aEndValue)

   137 	{

   138 	iAppUi.iProgress->Update(aStartValue, aEndValue);

   139 	}

   140 

   141 // -----------------------------------------------------------------------------

   142 // Removes the displayed progress bar

   143 // -----------------------------------------------------------------------------

   144 //

   145 void CStateMachine::StopProgressBar() const

   146 	{

   147 	iAppUi.iProgress->Cancel();

   148 	}

   149 

   150 // -----------------------------------------------------------------------------

   151 // Sets the failure state and reason for exit

   152 // -----------------------------------------------------------------------------

   153 //

   154 void CStateMachine::SetFailureReason(TExitReason aReason)

   155 	{

   156 	iAppUi.iExitReason = aReason;

   157 	iFailedState = (CStateFactory::TAppState)StateIndex();

   158 	// If the device is not supported, don't create resume info

   159 	if (aReason == EDeviceNotSupported)

   160 		{

   161 		iAppUi.iIsResumeRequired = EFalse;

   162 		}

   163 	}

   164 

   165 // -----------------------------------------------------------------------------

   166 // Shows the download query dialog with a specified text.

   167 // @param aResourceId Resource ID for the text to be shown.

   168 // @param aInfoResourceId Resource ID for additional information text.

   169 // -----------------------------------------------------------------------------

   170 //

   171 void CStateMachine::ShowDownloadQueryL(const TInt aResourceId, const TInt aInfoResourceId)

   172 	{

   173 	iAppUi.ShowDownloadQueryL( aResourceId, aInfoResourceId );

   174 	}

   175 

   176 // -----------------------------------------------------------------------------

   177 // Shows wait note

   178 // -----------------------------------------------------------------------------

   179 //

   180 void CStateMachine::ShowWaitNoteL(const TInt aResourceId)

   181 	{

   182 	iAppUi.ShowWaitNoteL( aResourceId, ETrue );

   183 	}

   184 

   185 // -----------------------------------------------------------------------------

   186 // Shows wait note with the specified values

   187 // -----------------------------------------------------------------------------

   188 //

   189 void CStateMachine::ShowInstallingWaitNoteL(const TInt aCurrent, const TInt aLast)

   190 	{

   191 	iAppUi.ShowWaitNoteNumL( R_ADM_INSTALLING_TEXT, aCurrent, aLast );

   192 	}

   193 

   194 // -----------------------------------------------------------------------------

   195 // Shows the progress bar with the specified values

   196 // -----------------------------------------------------------------------------

   197 //

   198 void CStateMachine::ShowProgressBarL(const TInt aStartValue, const TInt aEndValue, const TInt aCurrent, const TInt aLast)

   199 	{

   200 	iAppUi.ShowGlobalProgressL( R_ADM_DOWNLOADING_TEXT,

   201 			aStartValue, aEndValue,

   202 			aCurrent, aLast );

   203 	}

   204 

   205 // -----------------------------------------------------------------------------

   206 // Stops the wait note

   207 // -----------------------------------------------------------------------------

   208 //

   209 void CStateMachine::StopWaitNote()

   210 	{

   211 	iAppUi.CancelWaitNote();

   212 	}

   213 

   214 // -----------------------------------------------------------------------------

   215 // Starts the state machine from the initial state.

   216 // -----------------------------------------------------------------------------

   217 //

   218 void CStateMachine::Start()

   219 	{

   220 	LOG( "+ CStateMachine::Start()" );

   221 

   222 	// If the initial state has been set, don't change it here

   223 	if (!iState)

   224 		{

   225 		iState = &iStateFactory->GetState( CStateFactory::EStateSetup );

   226 		}

   227 

   228 	iStatus = KRequestPending;

   229 	SetActive();

   230 	// send signal that this request has completed

   231 	TRequestStatus* status = &iStatus;

   232 	User::RequestComplete(status, KErrNone);

   233 	}

   234 

   235 // -----------------------------------------------------------------------------

   236 // Stops the state machine

   237 // -----------------------------------------------------------------------------

   238 //

   239 void CStateMachine::Stop()

   240 	{

   241 	LOG( "+ CStateMachine::Stop()" );

   242 	Cancel();

   243 	iDepTree->RemoveDownloadedFiles( FsSession() );

   244 	// Log statistics. Prevent divide-by-zero.

   245 	if (iDownloadTime == 0)

   246 		iDownloadTime = 1;

   247 	LOG4( "Total %d kB in %.1f s, avg %.2f kB/s",

   248 			iCumulativeDownloaded/1024,

   249 			iDownloadTime/1000000.0,

   250 			iCumulativeDownloaded*1000000.0 / iDownloadTime / 1024.0);

   251 	}

   252 

   253 // -----------------------------------------------------------------------------

   254 // Returns current state ID

   255 // -----------------------------------------------------------------------------

   256 //

   257 TInt CStateMachine::StateIndex() const

   258 	{

   259 	return iStateFactory->StateIndex(iState);

   260 	}

   261 

   262 // -----------------------------------------------------------------------------

   263 // Request the next state we want the application to go to

   264 // -----------------------------------------------------------------------------

   265 //

   266 void CStateMachine::SetState(const CStateFactory::TAppState aState)

   267 	{

   268 	SetState( iStateFactory->GetState(aState) );

   269 	}

   270 

   271 // -----------------------------------------------------------------------------

   272 // Set the starting state of the state machine, but do not invoke state change

   273 // -----------------------------------------------------------------------------

   274 //

   275 void CStateMachine::SetStartState(const CStateFactory::TAppState aState)

   276 	{

   277 	iState = &iStateFactory->GetState( aState );

   278 	}

   279 

   280 // -----------------------------------------------------------------------------

   281 // Request the next state we want the application to go to

   282 // -----------------------------------------------------------------------------

   283 //

   284 void CStateMachine::SetState(TState& aState)

   285 	{

   286 	LOG3( "+ SetState(): %d -> %d", iStateFactory->StateIndex(iState), iStateFactory->StateIndex(&aState) );

   287 

   288 	iState->Exit();

   289 	iState = &aState;

   290 	SetActive();

   291 	// send signal that this request has completed

   292 	TRequestStatus* status = &iStatus;

   293 	User::RequestComplete(status, KErrNone);

   294 

   295 	//LOG2( "- SetState(): now in %d", iStateFactory->StateIndex(iState) );

   296 	}

   297 

   298 // -----------------------------------------------------------------------------

   299 // Active object heart

   300 // -----------------------------------------------------------------------------

   301 //

   302 void CStateMachine::RunL()

   303 	{

   304 	//LOG2( "+ CStateEngine::RunL(): state=%d", iStateFactory->StateIndex(iState) );

   305 	iState->Enter();

   306 	//LOG2( "- CStateEngine::RunL(): %d", iStateFactory->StateIndex(iState) );

   307 	}

   308 

   309 // -----------------------------------------------------------------------------

   310 // Handles the leaves from RunL().

   311 //

   312 // SPECIFIC CASES NOT DONE YET:

   313 // -

   314 // -----------------------------------------------------------------------------

   315 //

   316 TInt CStateMachine::RunError(const TInt aError)

   317 	{

   318 	LOG3("+ SM::RunError(): %d, %d", StateIndex(), aError );

   319 

   320 	TExitReason err = EInstallationFailed;

   321 

   322 	switch ( aError )

   323 		{

   324 		case KLeaveExit:

   325 			{

   326 			// TODO: Ugly hack: we need to return KLeaveExit as RunError()

   327 			// gets called when application exit is called within RunL().

   328 			//LOG( "Exit() left" );

   329 			return KLeaveExit;

   330 			}

   331 		case SwiUI::KSWInstErrUserCancel:

   332 			{

   333 			LOG( "User cancelled installation" );

   334 			// User cancelled the installation

   335 			err = EUserCancelled;

   336 			}

   337 			break;

   338 		case SwiUI::KSWInstErrInsufficientMemory:

   339 			{

   340 			LOG( "Installer left: not enough space" );

   341 			err = EInsufficientMemory;

   342 			}

   343 			break;

   344 		case SwiUI::KSWInstErrMissingDependency:

   345 			{

   346 			LOG( "Installer left: missing dependency." );

   347 			//err = EInstallationFailed;

   348 			}

   349 			break;

   350 		case SwiUI::KSWInstErrFileCorrupted:

   351 		case SwiUI::KSWInstErrPackageNotSupported:

   352 		case SwiUI::KSWInstErrGeneralError:

   353 		case SwiUI::KSWInstErrNoRights:

   354 		case SwiUI::KSWInstErrNetworkFailure:

   355 		case SwiUI::KSWInstErrAccessDenied:

   356 		case SwiUI::KSWInstUpgradeError:

   357 			{

   358 			LOG2( "Installer left, err=%d", aError );

   359 			//err = EInstallationFailed;

   360 			}

   361 			break;

   362 		case KErrServerTerminated:

   363 			{

   364 			LOG( "Server process terminated, cannot continue." );

   365 			}

   366 			break;

   367 		case EUnsupportedDevice:

   368 			{

   369 			LOG( "MachineId not present in supported devices list" );

   370 			err = EDeviceNotSupported;

   371 			}

   372 			break;

   373 		case KErrAlreadyExists:

   374 			{

   375 			// Download already exists

   376 			LOG( "Existing download" );

   377 			err = EDownloadFailed;

   378 			}

   379 			break;

   380 		default:

   381 			{

   382 			LOG2( "Uncategorized leave %d, exiting", aError );

   383 			}

   384 			break;

   385 		}

   386 

   387 	LOG2( "Exiting due to failure %d", err );

   388 	SetFailureReason( err );

   389 	SetState( CStateFactory::EStatePrepareExitWithError );

   390 

   391 	return KErrNone;

   392 	}

   393 

   394 // -----------------------------------------------------------------------------

   395 //

   396 // -----------------------------------------------------------------------------

   397 //

   398 void CStateMachine::DoCancel()

   399 	{

   400 	LOG( "CStateMachine::DoCancel()" );

   401 	iDownloadHandler->CancelAllDownloads();

   402 	iInstallManager->CancelAll();

   403 	}

   404 

   405 // -----------------------------------------------------------------------------

   406 // Sets the internet access point identifier for download handler

   407 // -----------------------------------------------------------------------------

   408 //

   409 void CStateMachine::SetIAP(TUint32 aIAP)

   410 	{

   411 	iDownloadHandler->SetIAP(aIAP);

   412 	}

   413 

   414 // -----------------------------------------------------------------------------

   415 // Handles the UI event from AppUi, filters it and passes it to states.

   416 // -----------------------------------------------------------------------------

   417 //

   418 void CStateMachine::HandleUserResponse(TInt aStatus)

   419 	{

   420 	switch (aStatus)

   421 		{

   422 		case EAknSoftkeyYes:

   423 			iState->UserAccepted();

   424 			break;

   425 		case EAknSoftkeyNo:

   426 			iState->UserRejected();

   427 			break;

   428 		case EAknSoftkeyCancel:

   429 		case EKeyPhoneEnd:

   430 			// fall-through

   431 		default:

   432 			iState->UserCancelled();

   433 			break;

   434 		}

   435 	}

   436 

   437 // -----------------------------------------------------------------------------

   438 //

   439 // -----------------------------------------------------------------------------

   440 //

   441 void CStateMachine::HandleInstallCompletedL(TInt aStatus)

   442 	{

   443 	LOG4( "HandleInstallCompletedL(%d): %d. '%S'", aStatus, StateIndex(), iCurrentPackage->GetSisPackageName() );

   444 	// TODO: Can iCurrentPackage ever be null? In case of root package installation??

   445 

   446 	iState->InstallCompleted( aStatus );

   447 	}

   448 

   449 // -----------------------------------------------------------------------------

   450 // Called, if IAP has changed

   451 // -----------------------------------------------------------------------------

   452 //

   453 void CStateMachine::HandleIapChanged(const TUint32 aIAP)

   454 	{

   455 	iAppUi.iIAP = aIAP;

   456 	SetIAP(aIAP);

   457 	}

   458 

   459 // -----------------------------------------------------------------------------

   460 // Called when download has finished.

   461 // -----------------------------------------------------------------------------

   462 //

   463 void CStateMachine::HandleHttpFetchCompleted(

   464 		const TDesC& aDlFilename,

   465 		const TInt /* aDownloadType */,

   466 		const TInt32 aBytesDownloaded,

   467 		const TReal32 aAvgDlSpeed, // bytes/second

   468 		const TInt64 aDlTime       // microseconds

   469 		)

   470 	{

   471 	delete iDownloadedFile;

   472 	iDownloadedFile = NULL;

   473 	iDownloadedFile = aDlFilename.Alloc();

   474 	iDownloadSize = aBytesDownloaded;

   475 	// Indicate that we've downloaded this amount already to keep progress bar happy

   476 	iCumulativeDownloaded += aBytesDownloaded;

   477 	// Calculate cumulative average download speed

   478 	iDownloadTime += aDlTime;

   479 

   480 #ifdef DEBUG_ADM

   481 	TReal32 avgDlSpeed = iCumulativeDownloaded*1000000.0 / iDownloadTime;

   482 

   483 #ifdef _DEBUG

   484 	TBuf<32> buf;

   485 	TReal r = avgDlSpeed;

   486 	TRealFormat fmt(3, 2);

   487 	fmt.iType = KRealFormatFixed; // | KDoNotUseTriads;

   488 	buf.AppendNum(r/1024.0, fmt);

   489 	buf.Append(' ');

   490 	buf.Append(iAppUi.iPrefixKb);

   491 	buf.Append('/');

   492 	buf.Append('s');

   493 	iAppUi.EikonEnv()->InfoMsg(buf);

   494 #endif

   495 

   496 	LOG8( "DL %7d/%7d (%.1f s, %3.02f kB/s) (total: %d kB, %.1f s, avg %.02f kB/s) OK",

   497 			aBytesDownloaded, aBytesDownloaded, aDlTime/1000000.0, aAvgDlSpeed/1024.0,

   498 			iCumulativeDownloaded/1024, iDownloadTime/1000000.0, avgDlSpeed/1024.0 );

   499 #endif

   500 	iState->DownloadCompleted(aBytesDownloaded);

   501 	}

   502 

   503 // -----------------------------------------------------------------------------

   504 // Called when download manager has retrieved a packet from the network.

   505 // Required for updating the progress bar.

   506 // -----------------------------------------------------------------------------

   507 //

   508 void CStateMachine::HandleHttpFetchInProgress(const TInt32 aAlreadyDownloaded, const TInt32 aDownloadSize, const TReal32 aAvgDlSpeed)

   509 	{

   510 	iState->DownloadInProgress(aAlreadyDownloaded, aDownloadSize, aAvgDlSpeed);

   511 	}

   512 

   513 // -----------------------------------------------------------------------------

   514 // Called when download manager encounters a problem while downloading

   515 // -----------------------------------------------------------------------------

   516 //

   517 void CStateMachine::HandleHttpFetchFailure(

   518 		const TDesC& aDlFilename,

   519 		const TInt aGlobalErrorId,

   520 		const TInt aErrorId,

   521 		const TInt aFetchType

   522 		)

   523 	{

   524 	if (aFetchType)

   525 		{

   526 		LOG5( "+ HandleHttpFetchFailure(): %d. %d, %d '%S'", StateIndex(), aGlobalErrorId, aErrorId, &aDlFilename );

   527 		}

   528 	delete iDownloadedFile;

   529 	iDownloadedFile = NULL;

   530 	iDownloadedFile = aDlFilename.Alloc();

   531 	// TODO: Filter the errors here and invoke proper callbacks in states

   532 	iState->DownloadFailed();

   533 	LOG( "- HandleHttpFetchFailure()" );

   534 	}

   535 

   536 // -----------------------------------------------------------------------------

   537 // Signals the semaphore that download deleting is in progress (and the installation

   538 // can safely continue).

   539 // -----------------------------------------------------------------------------

   540 //

   541 void CStateMachine::HandleDownloadDeleting()

   542 	{

   543 	iDlDeletingSemaphore.Signal();

   544 	}

   545 

   546 // =============================================================================

   547 

   548 // -----------------------------------------------------------------------------

   549 //

   550 // -----------------------------------------------------------------------------

   551 //

   552 TState& CStateFactory::GetState(const TAppState aState) const

   553 	{

   554 	__ASSERT_DEBUG( aState < EStateLast, Panic(EPanicStateIndexOutOfBounds) );

   555 	return *iStates[aState];

   556 	}

   557 

   558 // -----------------------------------------------------------------------------

   559 //

   560 // -----------------------------------------------------------------------------

   561 //

   562 TInt CStateFactory::StateIndex(const TState* aState) const

   563 	{

   564 	TInt state;

   565 	for (state = 0; state < EStateLast; state++)

   566 		{

   567 		if (iStates[state] == aState)

   568 			{

   569 			return state;

   570 			}

   571 		}

   572 	// We end up here, if the state is not set, which may happen, if this

   573 	// is called before CStateMachine::Start() or CStateMachine::SetState().

   574 	return KUnknownState;

   575 	}

   576 

   577 // -----------------------------------------------------------------------------

   578 // Creates a new CStateFactory.

   579 // @return Newly created CStateFactory.

   580 // -----------------------------------------------------------------------------

   581 //

   582 CStateFactory* CStateFactory::NewL(CStateMachine& aStateMachine)

   583 	{

   584 	CStateFactory* self = new (ELeave) CStateFactory(aStateMachine);

   585 	CleanupStack::PushL(self);

   586 

   587 	// Create the states

   588 	self->iStates[EStateSetup]                      = new (ELeave) TStateSetup(*self);

   589 	self->iStates[EStateSetupParsing]               = new (ELeave) TStateSetupParsing(*self);

   590 	self->iStates[EStateBuildDepTree]               = new (ELeave) TStateBuildDepTree(*self);

   591 	self->iStates[EStateDownloadDepFile]            = new (ELeave) TStateDownloadDepFile(*self);

   592 	self->iStates[EStateParseDepFile]               = new (ELeave) TStateParseDepFile(*self);

   593 	self->iStates[EStateDownloadChangesFile]        = new (ELeave) TStateDownloadChangesFile(*self);

   594 	self->iStates[EStateParseChangesFile]           = new (ELeave) TStateParseChangesFile(*self);

   595 	self->iStates[EStateBuildFetchList]             = new (ELeave) TStateBuildFetchList(*self);

   596 	self->iStates[EStateVerifyAvailableDiskSpace]   = new (ELeave) TStateVerifyAvailableDiskSpace(*self);

   597 	self->iStates[EStateConfirmDownload]            = new (ELeave) TStateConfirmDownload(*self);

   598 	self->iStates[EStateConfirmRoamingDownload]     = new (ELeave) TStateConfirmRoamingDownload(*self);

   599 	self->iStates[EStateStartDependencyDownload]    = new (ELeave) TStateStartDependencyDownload(*self);

   600 	self->iStates[EStateDownloadDependency]         = new (ELeave) TStateDownloadDependency(*self);

   601 	self->iStates[EStateInstallDependency]          = new (ELeave) TStateInstallDependency(*self);

   602 	self->iStates[EStateInstallAppSis]              = new (ELeave) TStateInstallAppSis(*self);

   603 	self->iStates[EStateUninstallDependency]        = new (ELeave) TStateUninstallDependency(*self);

   604 	self->iStates[EStatePrepareExitWithError]       = new (ELeave) TStatePrepareExitWithError(*self);

   605 	self->iStates[EStateLaunchApp]                  = new (ELeave) TStateLaunchApp(*self);

   606 	self->iStates[EStateExit]                       = new (ELeave) TStateExit(*self);

   607 

   608 	CleanupStack::Pop();

   609 

   610 	return self;

   611 	}

   612 

   613 // -----------------------------------------------------------------------------

   614 // Default constructor

   615 // -----------------------------------------------------------------------------

   616 //

   617 CStateFactory::CStateFactory(CStateMachine& aStateMachine) :

   618 	iStateMachine(aStateMachine)

   619 	{

   620 	}

   621 

   622 // -----------------------------------------------------------------------------

   623 // Default destructor

   624 // -----------------------------------------------------------------------------

   625 //

   626 CStateFactory::~CStateFactory()

   627 	{

   628 	// Deletes all state objects

   629 	iStates.DeleteAll();

   630 	}

   631 

   632 // =============================================================================

   633 

   634 TState::TState(const CStateFactory& aFactory) :

   635 	iFactory(aFactory),

   636 	iStateMachine(aFactory.StateMachine())

   637 	{

   638 	}

   639 

   640 void TState::PanicInState(TStatePanic aPanic) const

   641 	{

   642 	Panic(aPanic, iFactory.StateIndex(this));

   643 	}

   644 

   645 // Change of states

   646 void TState::Enter() const

   647 	{

   648 	}

   649 

   650 void TState::Exit() const

   651 	{

   652 	}

   653 

   654 // Events from UI

   655 void TState::UserAccepted()

   656 	{

   657 	LOG_FUNC

   658 	}

   659 

   660 // -----------------------------------------------------------------------------

   661 // Implements the default user cancel behaviour. If needed, overwrite in the

   662 // state implementation.

   663 // -----------------------------------------------------------------------------

   664 //

   665 void TState::UserCancelled()

   666 	{

   667 	LOG_FUNC

   668 	iStateMachine.SetFailureReason(EUserCancelled);

   669 	iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

   670 	}

   671 

   672 // -----------------------------------------------------------------------------

   673 // Implements the default user reject behaviour. If needed, overwrite in the

   674 // state implementation.

   675 // -----------------------------------------------------------------------------

   676 //

   677 void TState::UserRejected()

   678 	{

   679 	UserCancelled();

   680 	}

   681 

   682 // Events from DownloadManager

   683 void TState::DownloadInProgress(const TInt /* aAlreadyDownloaded */, const TInt /* aDownloadSize */, const TReal32 /* aAvgDlSpeed */)

   684 	{

   685 	//LOG_FUNC

   686 	}

   687 

   688 void TState::DownloadCompleted(const TInt /* aBytesDownloaded */)

   689 	{

   690 	LOG_FUNC

   691 	}

   692 

   693  void TState::DownloadFailed()

   694 	{

   695 	LOG_FUNC

   696 	}

   697 

   698 void TState::DownloadFailed(const CStateFactory::TAppState aState)

   699 	{

   700 	const EDownloadError errId = iStateMachine.iDownloadHandler->GetDownloadError();

   701 	SLOG3( "+ DownloadFailed(): %d. err=%d", iStateMachine.StateIndex(), errId );

   702 

   703 	if ( (errId == EDlErrDownloadFailure ) && ( iStateMachine.iRestartAttempt < KDownloadRestartRetries) )

   704 		{

   705 		iStateMachine.iRestartAttempt++;

   706 		SLOG2( "Download restart, attempt %d", iStateMachine.iRestartAttempt );

   707 		iStateMachine.SetState( aState );

   708 		}

   709 	else

   710 		{

   711 		SLOG3( "Aborting download. (%d; %d)", iStateMachine.iRestartAttempt, errId );

   712 //      iStateMachine.iRestartAttempt = 0;

   713 		iStateMachine.SetFailureReason(EDownloadFailed);

   714 		iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

   715 		}

   716 	}

   717 

   718 void TState::DownloadCancelled()

   719 	{

   720 	LOG_FUNC

   721 	iStateMachine.SetFailureReason(EUserCancelled);

   722 	iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

   723 	}

   724 

   725 // Events from InstallManager

   726 void TState::InstallInProgress()

   727 	{

   728 	LOG_FUNC

   729 	}

   730 

   731 void TState::InstallCompleted(TInt /* aStatus */)

   732 	{

   733 	LOG_FUNC

   734 	}

   735 

   736 void TState::InstallationCancelled()

   737 	{

   738 	LOG_FUNC

   739 	}

   740 

   741 // =============================================================================

   742 TStateSetup::TStateSetup(const CStateFactory& aFactory) :

   743 	TState(aFactory)

   744 	{

   745 	LOG_FUNC

   746 	}

   747 

   748 void TStateSetup::Enter() const

   749 	{

   750 	LOG_FUNC

   751 

   752 	// TODO: Check if we are roaming and proceed according to that

   753 

   754 	iStateMachine.SetState( CStateFactory::EStateSetupParsing );

   755 	}

   756 

   757 TStateSetupParsing::TStateSetupParsing(const CStateFactory& aFactory) :

   758 	TState(aFactory)

   759 	{

   760 	}

   761 

   762 void TStateSetupParsing::Enter() const

   763 	{

   764 	const TInt mUid = iStateMachine.MachineUid();

   765 	if ( mUid )

   766 		{

   767 		iStateMachine.iDepTree->SetMachineId( mUid );

   768 		}

   769 	else

   770 		{

   771 		PanicInState( EPanicStateInvalidMachineUid );

   772 		}

   773 

   774 	// Get the drive where wrapper package was installed to

   775 	const TBool driveStatus = iStateMachine.iInstallManager->GetPackageInstalledDriveL(

   776 			iStateMachine.WrapperPackageUid(),

   777 			iStateMachine.iWrapperInstalledDrive);

   778 

   779 

   780 #ifdef __WINS__

   781 	iStateMachine.iWrapperInstalledDrive = 'C';

   782 #else

   783 	if ( !driveStatus )

   784 		{

   785 		// Read the wrapper installed drive from resume info file.

   786 		// TODO: What if user has tried to install on a removable drive and it's not available during the menu launch?

   787 		}

   788 #endif

   789 

   790 	SLOG3( "Installer pkg on %c: (%d)", (char)iStateMachine.iWrapperInstalledDrive, driveStatus );

   791 

   792 	// Cannot combine this with drive status. User might be trying to reinstall an app, already present in the device!

   793 	TVersion version, minVersion = KMinBootstrapSisVersion;

   794 	if ( iStateMachine.iInstallManager->GetPackageVersionInfoL(KUidBootstrap, version) )

   795 		{

   796 		// Compare installed and min required Bootstrap versions

   797 		if ( CompareVersions(minVersion, version) == EGreaterFirstVersion )

   798 			{

   799 			iStateMachine.SetFailureReason( EInvalidBootstrapVersion );

   800 			iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

   801 			return;

   802 			}

   803 		}

   804 	else

   805 		{

   806 		// Launched from the menu grid

   807 		}

   808 

   809 	switch ( iStateMachine.BootstrapVersion() )

   810 		{

   811 		case 1:

   812 		case 2:

   813 		case 3:

   814 			{

   815 			// Parses the dependency file included withing the wrapper package.

   816 			SLOG2( "* Parsing '%S'", iStateMachine.DepFilename() );

   817 			iStateMachine.iXmlParser->GetDepContentsL(

   818 					*iStateMachine.DepFilename(),

   819 					iStateMachine.iCurrentPackage,

   820 					iStateMachine.iDepTree

   821 				);

   822 			iStateMachine.SetState( CStateFactory::EStateBuildDepTree );

   823 			}

   824 			break;

   825 		case 4:

   826 			{

   827 			// Parses the application.sis file included in the wrapper package.

   828 			SLOG2( "* Parsing '%S'", iStateMachine.SisFilename() );

   829 			iStateMachine.iSisParser->GetDepContentsL(

   830 					*iStateMachine.SisFilename(),

   831 					iStateMachine.iCurrentPackage,

   832 					iStateMachine.iDepTree

   833 				);

   834 			iStateMachine.SetState( CStateFactory::EStateBuildDepTree );

   835 			}

   836 			break;

   837 		default:

   838 			{

   839 			SLOG2( "Invalid bootstrap v%d", iStateMachine.BootstrapVersion() );

   840 			iStateMachine.SetFailureReason( EInvalidBootstrapVersion );

   841 			iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

   842 			}

   843 			break;

   844 		}

   845 	}

   846 

   847 // -----------------------------------------------------------------------------

   848 //

   849 // -----------------------------------------------------------------------------

   850 //

   851 TStateParseDepFile::TStateParseDepFile(const CStateFactory& aFactory) :

   852 	TState(aFactory)

   853 	{

   854 	}

   855 

   856 void TStateParseDepFile::Enter() const

   857 	{

   858 	SLOG2( "+ ParseDepFileL(): '%S'", iStateMachine.iDownloadedFile );

   859 	iStateMachine.iXmlParser->GetDepContentsL(

   860 			*iStateMachine.iDownloadedFile,

   861 			iStateMachine.iCurrentPackage,

   862 			iStateMachine.iDepTree

   863 		);

   864 	iStateMachine.SetState( CStateFactory::EStateBuildDepTree );

   865 	SLOG2( "- ParseDepFileL(): '%S'", iStateMachine.iDownloadedFile );

   866 	}

   867 

   868 // -----------------------------------------------------------------------------

   869 //

   870 // -----------------------------------------------------------------------------

   871 //

   872 TStateParseChangesFile::TStateParseChangesFile(const CStateFactory& aFactory) :

   873 	TState(aFactory)

   874 	{

   875 	}

   876 

   877 void TStateParseChangesFile::Enter() const

   878 	{

   879 	SLOG2("+ ParseChangesFileL(): '%S'", iStateMachine.iDownloadedFile);

   880 	// Parse the provided changes file.

   881 	// the parameter aChangesFileName will be invalid after the call

   882 	iStateMachine.iXmlParser->GetChangesInfoL(

   883 			*iStateMachine.iDownloadedFile,

   884 			iStateMachine.iCurrentPackage,

   885 			iStateMachine.iDepTree

   886 		);

   887 	iStateMachine.SetState( CStateFactory::EStateDownloadDepFile );

   888 	SLOG2( "- ParseChangesFileL(): '%S'", iStateMachine.iDownloadedFile );

   889 	}

   890 

   891 // -----------------------------------------------------------------------------

   892 //

   893 // -----------------------------------------------------------------------------

   894 //

   895 TStateBuildFetchList::TStateBuildFetchList(const CStateFactory& aFactory) :

   896 	TState(aFactory)

   897 	{

   898 	}

   899 

   900 void TStateBuildFetchList::Enter() const

   901 	{

   902 	// Construct the list of dependent packages

   903 	SLOG( "Building dependency list" );

   904 	iStateMachine.iDepTree->ConstructFetchListL();

   905 

   906 	// Remove all downloaded dep files

   907 	SLOG( "Removing downloaded files" );

   908 	iStateMachine.iDepTree->RemoveDownloadedFiles( iStateMachine.FsSession() );

   909 

   910 	// Check if cycle exists

   911 	if ( iStateMachine.iDepTree->IsCyclePresent() )

   912 		{

   913 		// TODO: Inform user about configuration failure, exit gracefully

   914 		SLOG( "! Failure: cycle exists in the graph." );

   915 		iStateMachine.SetFailureReason( EInstallationFailed );

   916 		iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

   917 		}

   918 	iStateMachine.SetState( CStateFactory::EStateVerifyAvailableDiskSpace );

   919 	}

   920 

   921 // -----------------------------------------------------------------------------

   922 //

   923 // -----------------------------------------------------------------------------

   924 //

   925 TStateVerifyAvailableDiskSpace::TStateVerifyAvailableDiskSpace(const CStateFactory& aFactory) :

   926 	TState(aFactory)

   927 	{

   928 	}

   929 

   930 void TStateVerifyAvailableDiskSpace::Enter() const

   931 	{

   932 	// MaxDownloadSize is subtracted from available System drive space.

   933 

   934 	// In case of silent installation of main app, if there is no space available in the drive selected by the user for wrapper,

   935 	// normal installation to follow.

   936 

   937 	// Set the drive info

   938 	if ( iStateMachine.iDepTree->SetDriveInfo() )

   939 		{

   940 		// With Ovi Store prompt always

   941 		const TInt dlThreshold = iStateMachine.OviStoreRunning()

   942 				? 0

   943 				: KDownloadPromptThreshold;

   944 		const TInt dlSize = iStateMachine.iDepTree->GetTotalDownloadSize();

   945 

   946 		SLOG3( "Download size %d (%d)", dlSize, dlThreshold );

   947 

   948 #ifdef DEBUG_ADM

   949 		// Print all the drives set. To be removed after testing.

   950 		CPackageInfo *node = NULL;

   951 		while( (node = iStateMachine.iDepTree->GetNextSortedNode()) != NULL )

   952 			{

   953 			SLOG5( "PkgUid 0x%08X: InstDrive %c:, prio %d, size %d",

   954 					node->GetPackageUid(), (char)node->GetInstallDrive(),

   955 					node->GetDrivePriority(), node->GetInstallSize() );

   956 			}

   957 #endif

   958 		// Show user how much to download and confirm, if he/she wants to do that

   959 		// if we have dependencies to download at all

   960 		if ( dlSize > 0 )

   961 			{

   962 			// Finalize the progress bar

   963 			iStateMachine.UpdateProgressBar( KProgressBarFullValue, KProgressBarFullValue );

   964 

   965 			// We need to download dependencies

   966 			if ( iStateMachine.UsingWLAN() && !iStateMachine.OviStoreRunning() )

   967 				{

   968 				// If using WLAN, start the dependency download immediately without prompting the user

   969 				iStateMachine.SetState( CStateFactory::EStateStartDependencyDownload );

   970 				}

   971 			else if ( iStateMachine.RegisteredRoaming() )

   972 				{

   973 				// If the device is roaming, always prompt the user

   974 				iStateMachine.SetState( CStateFactory::EStateConfirmRoamingDownload );

   975 				}

   976 			else if ( dlSize > dlThreshold )

   977 				{

   978 				// If not using WLAN and the download threshold has exceeded, prompt the user

   979 				iStateMachine.SetState( CStateFactory::EStateConfirmDownload );

   980 				}

   981 			else

   982 				{

   983 				// Otherwise, continue the download automatically without prompting the user

   984 				iStateMachine.SetState( CStateFactory::EStateStartDependencyDownload );

   985 				}

   986 			}

   987 		else

   988 			{

   989 			SLOG( "Nothing to download, dependencies OK." );

   990 			// Keep the next progress bar update happy

   991 			iStateMachine.iProgressMaxValue = KProgressBarFullValue;

   992 			// Finalize the progress bar

   993 			iStateMachine.UpdateProgressBar( KProgressBarFullValue*95/100, KProgressBarFullValue );

   994 			iStateMachine.SetState( CStateFactory::EStateInstallAppSis );

   995 			}

   996 		}

   997 	else

   998 		{

   999 		iStateMachine.SetFailureReason( EInsufficientMemory );

  1000 		iStateMachine.SetState( CStateFactory::EStatePrepareExitWithError );

  1001 		}

  1002 	}

  1003 

  1004 // -----------------------------------------------------------------------------

  1005 // Builds the dependency tree. This function controls the state machine.

  1006 // -----------------------------------------------------------------------------

  1007 //

  1008 TStateBuildDepTree::TStateBuildDepTree(const CStateFactory& aFactory) :

  1009 	TState(aFactory)

  1010 	{

  1011 	}

  1012 

  1013 void TStateBuildDepTree::Enter() const

  1014 	{

  1015 	SLOG2( "+ BuildDepTreeL(%d)", iStateMachine.iNodesProcessed );

  1016 

  1017 	// Update progress bar

  1018 	iStateMachine.iNodesProcessed++;

  1019 

  1020 	iStateMachine.iCurrentPackage = iStateMachine.iDepTree->GetNextNode();

  1021 	CPackageInfo* package = iStateMachine.iCurrentPackage;

  1022 

  1023 	if ( package == NULL )

  1024 		{

  1025 		SLOG( "Last package processed" );

  1026 		// Do the final progress bar update

  1027 		iStateMachine.UpdateProgressBar( KProgressBarFullValue*95/100, KProgressBarFullValue );

  1028 

  1029 		iStateMachine.SetState( CStateFactory::EStateBuildFetchList );

  1030 		}

  1031 	else

  1032 		{

  1033 		SLOG3( "* Processing 0x%08X (%d)", package->GetPackageUid(), package->GetPackageStatus() );

  1034 

  1035 		iStateMachine.UpdateProgressBar( iStateMachine.iNodesProcessed,

  1036 				iStateMachine.iNodesProcessed+2 );

  1037 

  1038 		// Call the install class api to validate and set the package status

  1039 		TUid uid = TUid::Uid( package->GetPackageUid() );

  1040 		TVersion version, test;

  1041 

  1042 		test = package->GetPackageVersion();

  1043 

  1044 		if (iStateMachine.iInstallManager->GetPackageVersionInfoL(uid, version))

  1045 			{

  1046 			// Compare installed and required verions

  1047 			// to find if upgrade is required.

  1048 			if ( (CompareVersions(test, version) ) == EGreaterFirstVersion)

  1049 				{

  1050 				SLOG8( "Package 0x%08X: upgrade %d.%02d.%d -> %d.%02d.%d",

  1051 						uid.iUid,

  1052 						version.iMajor, version.iMinor, version.iBuild,

  1053 						test.iMajor, test.iMinor, test.iBuild

  1054 						);

  1055 				package->SetPackageStatus(EPackageToBeUpgraded);

  1056 				}

  1057 			else

  1058 				{

  1059 				SLOG5( "Package 0x%08X: v%d.%02d.%d already installed", uid.iUid,

  1060 						version.iMajor, version.iMinor, version.iBuild

  1061 						);

  1062 				package->SetPackageStatus(EPackageInstalled);

  1063 				}

  1064 			}

  1065 		else

  1066 			{

  1067 			SLOG5( "Package 0x%08X: v%d.%02d.%d to be downloaded", uid.iUid,

  1068 					test.iMajor, test.iMinor, test.iBuild

  1069 					);

  1070 			package->SetPackageStatus(EPackageToBeFetched);

  1071 			}

  1072 

  1073 		iStateMachine.SetState( CStateFactory::EStateDownloadChangesFile );

  1074 		}

  1075 	SLOG2( "- BuildDepTreeL(%d)", iStateMachine.iNodesProcessed );

  1076 	}

  1077 

  1078 // -----------------------------------------------------------------------------

  1079 // Requests a download for the dependecy sis package _dep.xml file.

  1080 // -----------------------------------------------------------------------------

  1081 //

  1082 TStateDownloadDepFile::TStateDownloadDepFile(const CStateFactory& aFactory) :

  1083 	TState(aFactory)

  1084 	{

  1085 	}

  1086 

  1087 void TStateDownloadDepFile::Enter() const

  1088 	{

  1089 	//Here fetch the dep file of the current package.

  1090 	SLOG2( "+ FetchDepFileL(): 0x%08X", iStateMachine.iCurrentPackage->GetPackageUid() );

  1091 

  1092 	// TODO:Here the download Url should never be null]

  1093 	// as its mandatory to specify the Url in changes file.

  1094 	TPtrC8 urlPtr(NULL, 0);

  1095 	if (iStateMachine.iCurrentPackage->GetDownloadUrlL() != NULL)

  1096 		{

  1097 		SLOG8_2( "DepPkg URL: '%S'", iStateMachine.iCurrentPackage->GetDownloadUrlL() );

  1098 		urlPtr.Set(iStateMachine.iCurrentPackage->GetDownloadUrlL()->Des() );

  1099 		}

  1100 	else

  1101 		{

  1102 		SLOG8_2( "DepPkg URL: '%S' (default)", iStateMachine.ConfigUrl() );

  1103 		urlPtr.Set( *iStateMachine.ConfigUrl() );

  1104 		}

  1105 

  1106 	User::LeaveIfNull( iStateMachine.iCurrentPackage->GetDepFileName() );

  1107 

  1108 	SLOG2( "Downloading DEP: '%S'", iStateMachine.iCurrentPackage->GetDepFileName() );

  1109 

  1110 	iStateMachine.iDownloadHandler->StartDownloadL(

  1111 		urlPtr,

  1112 		*iStateMachine.iCurrentPackage->GetDepFileName(),

  1113 		iStateMachine.iDepTree->GetDownloadPath(),

  1114 		1);

  1115 	// We don't request a new state after this. When download completes

  1116 	// succesfully, a new state change will be requested.

  1117 	}

  1118 

  1119 void TStateDownloadDepFile::DownloadCompleted(const TInt /* aBytesDownloaded */)

  1120 	{

  1121 	iStateMachine.iRestartAttempt = 0;

  1122 	iStateMachine.SetState( CStateFactory::EStateParseDepFile );

  1123 	}

  1124 

  1125 void TStateDownloadDepFile::DownloadFailed()

  1126 	{

  1127 	LOG_FUNC

  1128 	TState::DownloadFailed( CStateFactory::EStateDownloadDepFile );

  1129 	}

  1130 

  1131 // -----------------------------------------------------------------------------

  1132 // Requests a download for the _changes.xml file.

  1133 // -----------------------------------------------------------------------------

  1134 //

  1135 TStateDownloadChangesFile::TStateDownloadChangesFile(const CStateFactory& aFactory) :