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

/**
 @file
 @internalComponent
*/

#include "amastartasync.h"

#include "ssmdebug.h"

CAmaStartAsync* CAmaStartAsync::NewL( RMessage2 aMessage )
	{
	DEBUGPRINT1A( ">CAmaStartAsync::NewL" );
	
	CAmaStartAsync* self = NewLC( aMessage );
	CleanupStack::Pop();
	
	DEBUGPRINT1A( "CAmaStartAsync::NewL>" );
	return self;
	}
	
	
	
CAmaStartAsync* CAmaStartAsync::NewLC( RMessage2 aMessage )
	{
	DEBUGPRINT1A( ">CAmaStartAsync::NewLC" );
	
	CAmaStartAsync* self = new(ELeave) CAmaStartAsync( aMessage );
	CleanupStack::PushL( self );
	self->ConstructL();
	
	DEBUGPRINT1A( ">CAmaStartAsync::NewLC" );
	return self;
	}



CAmaStartAsync::~CAmaStartAsync()
	{
	DEBUGPRINT1A( ">CAmaStartAsync::~CAmaStartAsync" );
	
	Cancel();

	delete iStartSafe;
	if (iDscStore.IsOpened())
		{
		iDscStore.Close();
		}
	iSysMon.Close();
	
	DEBUGPRINT1A( "CAmaStartAsync::~CAmaStartAsync>" );
	}



/**
 * Initiate AMA processing.
 */	
void CAmaStartAsync::StartL( const TUid& aDscId )
	{
	DEBUGPRINT1A( ">CAmaStartAsync::StartL" );
	
	if( iRunning )
		{
		User::Leave( KErrInUse );
		}

	DEBUGPRINT1( _L("***** Set running") );
	
	iRunning = ETrue;
	iDscStore.EnumOpenLC(aDscId);
	CleanupStack::Pop();
		
	SetActive();
	TRequestStatus* trs = &iStatus;
	User::RequestComplete( trs, KErrNone );
	
	DEBUGPRINT1A( "CAmaStartAsync::StartL>" );
	}



/**
 * Succsessive calls to StartDscItemL, but only one per RunL in order for
 * the scheduler/ server to remain responsive.
 */
void CAmaStartAsync::RunL()
	{
	DEBUGPRINT1A( ">CAmaStartAsync::RunL %d" );
	CDscItem* item = iDscStore.EnumReadNextL();
	if (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;
		
		SetActive();
		TRequestStatus* status = &iStatus;
		User::RequestComplete(status, KErrNone);
		
		}
	else // No more items in store, so finish here
		{
		iDscStore.EnumClose();
		iDscStore.Close();
		iMessage.Complete(KErrNone);
		}

	DEBUGPRINT1A( "CAmaStartAsync::RunL>" );
	}
	
	

TInt CAmaStartAsync::RunError( TInt aError )
	{
	DEBUGPRINT1A( ">CAmaStartAsync::RunError" );
	
	iDscStore.EnumClose();
	iDscStore.Close();
	iMessage.Complete(aError);
	
	DEBUGPRINT1A( "CAmaStartAsync::RunError>" );
	return KErrNone;
	}



/**
 * Cancel the current command.
 */
void CAmaStartAsync::DoCancel()
	{
	DEBUGPRINT1A( ">CAmaStartAsync::DoCancel" );

	if( iRunning )
		{
		iDscStore.EnumClose();
		iMessage.Complete(KErrCancel);
		iRunning = EFalse;
		}
	
	DEBUGPRINT1A( "CAmaStartAsync::DoCancel>" );
	}
	


void CAmaStartAsync::ConstructL()
	{
	DEBUGPRINT1A( ">CAmaStartAsync::ConstructL" );
	
	iStartSafe = CStartSafe::NewL();
	iDscStore.OpenL();
	CActiveScheduler::Add( this );
	
	DEBUGPRINT1A( "CAmaStartAsync::ConstructL>" );
	}
	
	
	
CAmaStartAsync::CAmaStartAsync( RMessage2 aMessage )
: CActive( EPriorityStandard ), iMessage( aMessage )
	{
	DEBUGPRINT1A( ">CAmaStartAsync::CAmaStartAsync> (Empty constructor)" );
	}
	
	

void CAmaStartAsync::StartDscItemL(const CDscItem& aDscItem)
	{
	DEBUGPRINT1A( ">CAmaStartAsync::StartDscItemL" );
	
	//A process to be created inside iStartSafe->StartL();
	RProcess 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);
	
	DEBUGPRINT2(_L("%d times has been retried to start the process successfully"), tried);

	TInt error=KErrNone;
	//monitor the process if indicated
	if(aDscItem.Monitored())
		{
		// first time monitoring, so connect with the SysMon server
		if (iSysMon.Handle() == KNullHandle)
			{
			TRAP(error, iSysMon.OpenL());
			}
		// monitor the process	
		if (KErrNone==error) 
			{
			TRAP(error, iSysMon.MonitorL(properties, process));
			}
		//Connect to SysMon fail or register to monitor the process fail
		//Kill the started process because Start and Monitor should be one atomic function.
		if (KErrNone !=error)
			{
			process.Kill(error);
			process.Close();
			}
		User::LeaveIfError(error);	
		}
		
	DEBUGPRINT1A( "CAmaStartAsync::StartDscItemL>" );
	}