/*

* Copyright (c) 2010 Kanrikogaku Kenkyusho, Ltd.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

* Kanrikogaku Kenkyusho, Ltd. - Initial contribution

*

* Contributors:

*

* Description:  

*

*/

#ifdef _DIRECTPRINT_USE_USB

#include <usbman.h>

#include <usbstates.h>

#include <usbpersonalityids.h>

#endif // _DIRECTPRINT_USE_USB

#include "directprintsession.h"

#include "directprintclientserver.h"

#include "directprintserver.h"

#include "clog.h"

#include "directprintbody.h"

#include "directprintserverjobguard.h"

#include "directprintnumofcopies.h"

namespace

	{

	// panic

	_LIT( KDirectPrintSessionPanic, "CIPSes" );

	enum TDirectPrintSessionPanic

		{

		ENotSupported

		};

	void PanicClient( const TDpMessage& aMessage, TDirectPrintSessionPanic aCategory )

		{

		aMessage.Panic( KDirectPrintSessionPanic, aCategory );

		}

	}

CDirectPrintSession::~CDirectPrintSession()

	{ 

	LOG("CDirectPrintSession::~CDirectPrintSession begin");

	delete iNumOfCopies;

	delete iJobGuard;

	iCapabilityIDs.Close();

	iMsgWrappers.ResetAndDestroy();

	iMsgWrappers.Close();

	Server().ReleaseEngine( this );

	Server().RemoveSession();

	LOG("CDirectPrintSession::~CDirectPrintSession end");

	}

CDirectPrintServer& CDirectPrintSession::Server()

    {

	return *static_cast<CDirectPrintServer*>( const_cast<CServer2*>( CSession2::Server() ) );

    }

void CDirectPrintSession::CreateL()

    {

    LOG("CDirectPrintSession::CreateL begin");

	Server().AddSession();

	iJobGuard = CDirectPrintServerJobGuard::NewL( Server().Engine() );

	iNumOfCopies = CDirectPrintNumOfCopies::NewL();

	iConnected = ETrue;

	LOG("CDirectPrintSession::CreateL end");

    }

void CDirectPrintSession::Disconnect(const RMessage2 &aMessage)

	{

	LOG("CDirectPrintSession::Disconnect begin");

//	Server().Engine().HandleSessionDisconnect( iIdleGuard, iDiscoveryGuard, iJobGuard );

	Server().Engine().HandleSessionDisconnect( NULL, NULL, iJobGuard );

	iConnected = EFalse;	

	CSession2::Disconnect( aMessage );

	LOG("CDirectPrintSession::Disconnect end");

	}

void CDirectPrintSession::ServiceL( const RMessage2& aMessage )

    {

    LOG1("CDirectPrintSession::ServiceL aMessage.Function(): %d", aMessage.Function());

    // wrapper array clean begin

	TInt index = iMsgWrappers.Count();

	LOG1("CDirectPrintSession::ServiceL index: %d", index);

	TBool result( EFalse );

	while( --index >= 0 && !result )

		{

		if( ( iMsgWrappers[index] )->Disposable() )

			{

			TDpMessage* toDispose = iMsgWrappers[index];

			iMsgWrappers.Remove( index );

			delete toDispose;

			toDispose = NULL;

			result = ETrue;

			}

		}	

	// wrapper array clean end

    TDpMessage* msgWrapper = new (ELeave) TDpMessage( aMessage, iConnected );    

    TInt err = iMsgWrappers.Insert( msgWrapper, 0 );

    if( err )

    	{

    	delete msgWrapper;

    	User::Leave( err );

    	}

    else

    	{

    	msgWrapper = NULL;

    	}    

    TInt messageIndex = aMessage.Function();

    if ( messageIndex <= EContinuePrintJob )

		{

	    ServiceFirstPartL( messageIndex );

		}

    else if ( messageIndex >= ERemoveCachedPrinter && messageIndex <= EGetPrinterCapHigh )

    	{

		ServiceSecondPartL( messageIndex );				

    	}		

    else if ( messageIndex >= EGetPrinterCapEnumCount && messageIndex <= EGetProtocolName )

    	{

		ServiceThirdPartL ( messageIndex );

    	}

    else 

    	{		

    	PanicClient( *iMsgWrappers[0], ENotSupported );    

    	}	

	LOG("CDirectPrintSession::ServiceL end");

    }

void CDirectPrintSession::ServiceFirstPartL( TInt aIndex )

	{

    switch( aIndex )

		{

		case ECountConnections:

			CountConnectionsL( *iMsgWrappers[0] );

			break;	

		case ESetForeground:

			SetForegroundL( *iMsgWrappers[0] );

			break;	

		case EReserveEngine:

			ReserveEngine( *iMsgWrappers[0] );

			break;

		case EReleaseEngine:

			ReleaseEngine( *iMsgWrappers[0] );

			break;	

		case ESupportedProtocols:

			SupportedProtocols( *iMsgWrappers[0] );

			break;	

		case EGetNumPrintPages:

			GetNumPrintPages( *iMsgWrappers[0] );

			break;	

		case EGetJobStatus:

			GetJobStatus( *iMsgWrappers[0] );

			break;	

		case EGetPrinterStatus:

			GetPrinterStatus( *iMsgWrappers[0] );

			break;	

		case ECancelDiscovery:

			CancelDiscovery( *iMsgWrappers[0] );

			break;	

		case ESubmitPrintJob:

			SubmitPrintJobL( *iMsgWrappers[0] );

			break;	

		case ECancelPrintJob:

			CancelPrintJob( *iMsgWrappers[0] );

			break;

		case EContinuePrintJob:

			ContinuePrintJobL( *iMsgWrappers[0] );

			break;

		default:

		LOG1("[CDirectPrintSession::ServiceFirstPartL]\t Method reached to an end with index: %d", aIndex);

			break;

		}

	}

void CDirectPrintSession::ServiceSecondPartL( TInt aIndex )

	{

    switch( aIndex )

		{

		case ERemoveCachedPrinter:

			RemoveCachedPrinterL( *iMsgWrappers[0] );

			break;

		case EGetJobTemplateIcon:

			GetJobTemplateIconL( *iMsgWrappers[0] );

			break;

		case EGetNumPreviewPages:

			GetNumPreviewPages( *iMsgWrappers[0] );

			break;

		case ESetJobSetting:

			SetJobSettingL( *iMsgWrappers[0] );

			break;	

		case EGetJobSetting:

			GetJobSettingL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapability:

			GetPrinterCapabilityL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapId:

			GetPrinterCapIdL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapType:

			GetPrinterCapTypeL( *iMsgWrappers[0] );

			break;

    	case EGetPrinterCapDef:

			GetPrinterCapDefL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapLow:

			GetPrinterCapLowL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapHigh:

			GetPrinterCapHighL( *iMsgWrappers[0] );

			break;	

		default:

			LOG1("[CDirectPrintSession::ServiceSecondPartL]\t Method reached to an end with index: %d", aIndex);

			break;

		}

	}

void CDirectPrintSession::ServiceThirdPartL( TInt aIndex )

	{

    switch( aIndex )

		{

		case EGetPrinterCapEnumCount:

			GetPrinterCapEnumCountL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapEnum:

			GetPrinterCapEnumL( *iMsgWrappers[0] );

			break;	

		case EGetPrinterCapabilityIDsCount:

			GetPrinterCapabilityIDsCountL( *iMsgWrappers[0] );

			break;

		case EGetPrinterCapabilityID:

			GetPrinterCapabilityIDL( *iMsgWrappers[0] );

			break;

		case ERegisterIdleObserver:

			RegisterIdleObserverL( *iMsgWrappers[0] );

			break;

		case ECancelRegisterIdleObserver:

			CancelRegisterIdleObserverL( *iMsgWrappers[0] );

			break;

		case EStartDiscovery:

			StartDiscoveryL( *iMsgWrappers[0] );

			break;

		case EContinueDiscovery:

			ContinueDiscoveryL( *iMsgWrappers[0] );

			break;

		case EPrepareJob:

			PrepareJobL( *iMsgWrappers[0] );

			break;

		case ECreateJob:

			CreateJobL( *iMsgWrappers[0] );

			break;			

		case EContinueCreateJob:

			ContinueCreateJobL( *iMsgWrappers[0] );

			break;

		case ECancelStartDiscovery:

			CancelStartDiscoveryL( *iMsgWrappers[0] );

			break;

		case ECancelCreateJob:

			CancelCreateJobL( *iMsgWrappers[0] );

			break;

		case EIsPictBridgeMode:

			IsPictBridgeModeL( *iMsgWrappers[0] );

			break;

		case ESetNumberOfCopiesCount:

			SetNumberOfCopiesCountL( *iMsgWrappers[0] );

			break;

		case ESetNumberOfCopies:

			SetNumberOfCopiesL( *iMsgWrappers[0] );

			break;

		case EGetProtocolNamesCount:

			GetProtocolNamesCountL( *iMsgWrappers[0] );

			break;

		case EGetProtocolName:

			GetProtocolNameL( *iMsgWrappers[0] );

			break;

		default:

			LOG1("[CDirectPrintSession::ServiceThirdPartL]\t Method reached to an end with index: %d", aIndex);

			break;

		}

	}

void CDirectPrintSession::CountConnectionsL( TDpMessage& aMessage )

	{	

	TInt count = Server().SessionCount();

	TPckgC<TInt> countDes( count );

	aMessage.WriteL( 0, countDes );

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( KErrNone );

	}

void CDirectPrintSession::SetForegroundL( TDpMessage& aMessage )

	{

	TInt fg = aMessage.Int0();

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( KErrNone );

	}

void CDirectPrintSession::ReserveEngine( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}

void CDirectPrintSession::ReleaseEngine( TDpMessage& aMessage )

	{

	TInt err = Server().ReleaseEngine( this );

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );	

	}

void CDirectPrintSession::SupportedProtocols( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	aMessage.SetDisposable( ETrue );

	if( !err )	

		{

		TInt protocols = Server().Engine().SupportedProtocols();

		aMessage.Complete( protocols );	

		}

	else

		{

		aMessage.Complete( err );	

		}

	}

void CDirectPrintSession::GetNumPrintPages( TDpMessage& aMessage )

{

	TInt err = Server().ReserveEngine( this );

	aMessage.SetDisposable( ETrue );

	if( !err )	

		{

		TInt pages = Server().Engine().GetNumPrintPages();

		aMessage.Complete( pages );	

		}

	else

		{

		aMessage.Complete( err );	

		}

	}	

void CDirectPrintSession::GetJobStatus( TDpMessage& aMessage )

{

	TInt err = Server().ReserveEngine( this );

	aMessage.SetDisposable( ETrue );

	if( !err )	

		{

		TInt status = Server().Engine().GetJobStatus();

		aMessage.Complete( status );	

		}

	else

		{

		aMessage.Complete( err );	

		}

	}	

void CDirectPrintSession::GetPrinterStatus( TDpMessage& aMessage )

{

	TInt err = Server().ReserveEngine( this );

	aMessage.SetDisposable( ETrue );

	if( !err )	

		{

		TInt id = aMessage.Int0();

		TInt status = Server().Engine().GetPrinterStatus( id );

		aMessage.Complete( status );	

		}

	else

		{

		aMessage.Complete( err );	

		}

	}

void CDirectPrintSession::CancelDiscovery( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	if( !err )	

		{

		Server().Engine().CancelDiscovery();

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}

void CDirectPrintSession::SubmitPrintJobL( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	if( !err )	

		{

		Server().Engine().SubmitPrintJobL();			

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}

void CDirectPrintSession::CancelPrintJob( TDpMessage& aMessage )

	{	

	TInt err = Server().ReserveEngine( this );

	if( !err )	

		{

		err = Server().Engine().CancelPrintJob();

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}

void CDirectPrintSession::ContinuePrintJobL( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	if( !err )	

		{

		err = Server().Engine().ContinuePrintJobL();			

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}			

void CDirectPrintSession::RemoveCachedPrinterL( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	if( !err )	

		{

		TInt id = aMessage.Int0();

		err = Server().Engine().RemoveCachedPrinterL( id );

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}

void CDirectPrintSession::GetJobTemplateIconL( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	if( !err )

		{

		TInt id = aMessage.Int0();

		TInt handle;

		err = Server().Engine().GetJobTemplateIconL( id, handle );

		TPckgC<TInt> handleDes( handle );

		aMessage.WriteL( 1, handleDes );

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );

	}

void CDirectPrintSession::GetNumPreviewPages( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	aMessage.SetDisposable( ETrue );

	if( !err )

		{

		TInt num = Server().Engine().GetNumPreviewPages();

		aMessage.Complete( num );

		}

	else

		{

		aMessage.Complete( err );

		}

	}

void CDirectPrintSession::SetJobSettingL( TDpMessage& aMessage )

	{

	TInt err = Server().ReserveEngine( this );

	if( !err )

		{

		TInt capabilityID = aMessage.Int0();

		TInt value = aMessage.Int1();

		TInt affectedCapability;

		LOG2("CDirectPrintSession::SetJobSettingL || capabilityID = %d, value = %d", capabilityID, value );

		err = Server().Engine().SetJobSettingL( capabilityID, value, affectedCapability );

		TPckgC<TInt> affectedCapabilityDes( affectedCapability );

		aMessage.WriteL( 2, affectedCapabilityDes );

		}

	aMessage.SetDisposable( ETrue );

	aMessage.Complete( err );