// Copyright (c) 2008-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:

//

#include "ssmdebug.h"

#include "amastart.h"

#include <dscitem.h>

#include <startsafe.h>

/**

 * Used to create an instance of CAmaStart class

 * @return An instance of CAmaStart

 */

EXPORT_C CAmaStart* CAmaStart::NewL()

	{

	CAmaStart* ama = new(ELeave) CAmaStart();

	CleanupStack::PushL(ama);

	ama->ConstructL();

	CleanupStack::Pop(ama);

	return ama;

	}

void CAmaStart::ConstructL()

	{

	iAmaStarter = CAmaStartAsync::NewL();

	iStartSafe = CStartSafe::NewL();

	}

CAmaStart::CAmaStart()

	{

	}

/**

 * Destructor for CAmaStart class

 */

EXPORT_C CAmaStart::~CAmaStart()

	{

	delete iStartSafe;

	iDscStore.Close();

	iSysMon.Close();

	delete iAmaStarter;

	}

/**

 * Used to launch AMAs (after market application) from a DSC. 

 * Returns when processing of the DSC is complete. 

 * (Synchronous)

 * @param aDscId Id of the DSC containing AMAs to be started.

 */

EXPORT_C void CAmaStart::StartL(const TUid aDscId)

	{

	if (iClientStatus && *iClientStatus == KRequestPending)

		{

		User::Leave(KErrNotReady);

		}

	// Opens a connection with the DSC database.

	iDscStore.OpenL();

	//Prepares the database to read the given details of the given dsc id

	iDscStore.EnumOpenLC(aDscId) ;

	//Read the details of the current dscid (aDscId) 

	CDscItem* item = iDscStore.EnumReadNextL();

	while (item)

		{

		//if loading of one AMA from the DSC fails we should move to next AMA - so we trap here 

		TRAP_IGNORE(StartDscItemL(*item));

		delete item;

		item = iDscStore.EnumReadNextL();

		}

	//EnumClose()

	//Pop and destroy cleanup rollback operation left on cleanstack by EnumOpenLC()

	CleanupStack::PopAndDestroy();

	}

/**

 * Used to begin launching AMAs (after market application) from a DSC.

 * Returns immediately. The supplied TRequestStatus object is used to signal completion. 

 * When the request is completed it will have one of the following values: 

 * KErrNone - if the request complete successfully

 * KErrCancel - if the request was cancelled using CAmaStart::CancelStart

 * KErrNotReady - if another asynchronous request is outstanding

 * KErrArgument - if a DSC with the supplied UID does not exist

 * or one of the other system-wide error codes.

 * (Asynchronous)

 * @param aDscId Id of the DSC containing AMAs to be started.

 * @param aRequestStatus Status object to signal completion.

 */

EXPORT_C void CAmaStart::Start(const TUid aDscId, TRequestStatus& aRequestStatus)

	{

	aRequestStatus = KRequestPending;

	TRequestStatus* trs = &aRequestStatus;

	if (iClientStatus && *iClientStatus == KRequestPending)

		{

		User::RequestComplete(trs, KErrNotReady);

		return;

		}

	iClientStatus = &aRequestStatus;

	TRAPD(err, iAmaStarter->StartL(aDscId, aRequestStatus));

	if (err != KErrNone)

		{

		//Complete the request with the error code returned

		User::RequestComplete(trs, err);

		return;

		}

	}

/**

 * Cancel's a pending asynchronous StarL request.

 * If there is no request pending, calling thisw method has no effect.

 */

EXPORT_C void CAmaStart::CancelStart()

	{

	iAmaStarter->Cancel();

	}

void CAmaStart::StartDscItemL(const CDscItem& aDscItem)

	{

	//A process to be created inside iStartSafe->StartL();

	RProcess process;

	CleanupClosePushL(process);

	//Number of retries made for starting the process.

	TInt tried = 0;

	// start the process

	const CStartupProperties& properties = aDscItem.StartupProperties();

	iStartSafe->StartL(properties, process, tried);

	DEBUGPRINT2A("CAmaStart::StartDscItemL(): %d times has been retried to start the process successfully", tried);

	//monitor the process if indicated

	if (aDscItem.Monitored())

		{

		TRAPD(error, MonitorProcessL(properties, process));

		//Kill the started process in case of an error as Start and Monitor should be one atomic function.

		if (KErrNone != error)

			{

			process.Kill(error);

			}

		}

	CleanupStack::PopAndDestroy(&process);

 	}

void CAmaStart::MonitorProcessL(const CStartupProperties& aProperties, const RProcess& aProcess)

	{

	// first time monitoring, so connect with the SysMon server

	if (KNullHandle == iSysMon.Handle())

		{

		iSysMon.OpenL();

		}

	// monitor the process	

	iSysMon.MonitorL(aProperties, aProcess);

	}