/*

* Copyright (c) 2004 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:  This module contains the implementation of CTFFactory class 

*	             member functions.

*

*/

// INCLUDE FILES

#include "siftrace.h"

#include "remconcontrol.h"

#include "remconcontroltestcase.h"

#include "ctffactory.h"

#include "tftypes.h"

#include "accremconpstypes.h"

DECLARE_TRACE_ASSERT

_LIT_SECURITY_POLICY_PASS( KWritePolicy );

_LIT_SECURITY_POLICY_PASS( KReadPolicy );

static TTFRemConkeyEvent MapRemConToTfKey( TRemConCoreApiOperationId aOperationId )

    {

    if ( aOperationId == ERemConCoreApiVolumeUp ) return ETFRemConEvent_VolumeUp;

    if ( aOperationId == ERemConCoreApiVolumeDown ) return ETFRemConEvent_VolumeDown;

    if ( aOperationId == ERemConCoreApiStop ) return ETFRemConEvent_CodeStop;

    if ( aOperationId == ERemConCoreApiFastForward ) return ETFRemConEvent_CodeForward;

    if ( aOperationId == ERemConCoreApiRewind ) return ETFRemConEvent_CodeBack;

    if ( aOperationId == ERemConCoreApiForward ) return ETFRemConEvent_CodeForward;

    if ( aOperationId == ERemConCoreApiBackward ) return ETFRemConEvent_CodeBack;

    if ( aOperationId == ERemConCoreApiPausePlayFunction ) return  ETFRemConEvent_CoreApiPlaybackSpeedX1; //event not used in real implementation

    if ( aOperationId == ERemConCoreApiMute )return ETFRemConEvent_Mute;

    return ETFRemConEvent_None;

    }

MRemConControl* GetRemConControl( void )

    {

    CTFStub* stub = CTFFactory::Stub( KTFStubTypeRemConControl );

    return STATIC_CAST( CRemConControl*, stub );

    }

MRemConControl::MRemConControl( void )

    {

    }

MRemConControl::~MRemConControl( void )

    {

    }

CRemConControl::CRemConControl( void )

: CTFRemoteStub( KTFStubTypeRemConControl )

    {

    iKeyEvent  = ETFRemConEvent_None;

    iParameter = 0; 

    iError     = 0;   

    iTargetInterfaceSelector = NULL; 

    iPocTarget               = NULL;

    iCoreTarget              = NULL;

    iSyncTarget              = NULL;    

    iCallTarget = NULL;

    }

//lint -e1740 Pointer not directly deleted by destructor

CRemConControl::~CRemConControl( void )

    {

    Finalize();

    COMPONENT_TRACE( ( _L( "CRemConControl::~CRemConControl()" ) ) );

    }

//lint +e1740    

void CRemConControl::InitializeL( void )

    {

    TInt retval = KErrNone;

    retval = RProperty::Define(KTFRemConTestProperty, KTFRemConTriggerCmdKey, RProperty::EByteArray, KReadPolicy, KWritePolicy);    

	if(retval != KErrAlreadyExists)

    	User::LeaveIfError(retval);           

    retval = RProperty::Define(KTFRemConTestProperty, KTFRemConTriggerNotifyCmdKey, RProperty::EByteArray, KReadPolicy, KWritePolicy);    

	if(retval != KErrAlreadyExists)

    	User::LeaveIfError(retval);       	

    User::LeaveIfError(iSubscribe.Attach(KTFRemConTestProperty, KTFRemConTriggerCmdKey));       

	TInt retval1 = KErrNone;

    retval1 = RProperty::Define(KPSUidCtsyCallInformation, KCTsyCallState, RProperty::EInt, KReadPolicy, KWritePolicy);    

	if(retval1 != KErrAlreadyExists)

		User::LeaveIfError(retval);           

    if ( iCmdReceiverFromStub == NULL)

        {

        iCmdReceiverFromStub = CRemConPSPCHObserver::NewL();

	    iCmdReceiverFromStub->Start();    

        }

    retval = RProperty::Define(KTFRemConTestProperty, KTFRemConClientKey, RProperty::EByteArray, KReadPolicy, KWritePolicy);    

    if( retval != KErrAlreadyExists )

        {

        User::LeaveIfError(retval);

        }

    COMPONENT_TRACE( ( _L( "CRemConControl::InitializeL - return" ) ) );

    }

void CRemConControl::SwapToNormalHandlerL( void )

    {

	 if(iTargetInterfaceSelector == NULL)

         {

	     iTargetInterfaceSelector  = CRemConInterfaceSelector::NewL();

         if(iPocTarget == NULL)

             {

             iPocTarget = CRemConPoc::NewL(iTargetInterfaceSelector);

             }

         if(iSyncTarget == NULL)

             {

        	 iSyncTarget = CRemConSync::NewL(iTargetInterfaceSelector);

        	 }

         if(iCallTarget == NULL)

             {

             iCallTarget = CRemConCall::NewL(iTargetInterfaceSelector);

             }

         if(iCoreTarget == NULL)

            {

            iCoreTarget = CRemConCore::NewL(iTargetInterfaceSelector);

            }

         if( !iTargetInterfaceSelector->ControllerOpened() )

            {

            iTargetInterfaceSelector->OpenControllerL();

            }

            if( !iTargetInterfaceSelector->TargetOpened() )

            {

            iTargetInterfaceSelector->OpenTargetL();		 

            }

        }

    }

void CRemConControl::Finalize( void )

    {

    COMPONENT_TRACE( ( _L( "CRemConControl::Finalize()" ) ) );

       if ( iPocTarget != NULL )

    		{

    		delete iPocTarget;

    		iPocTarget = NULL;

    		}

		if ( iCoreTarget != NULL )

    		{

    		delete iCoreTarget;

    		iCoreTarget = NULL;

    		}

		if ( iSyncTarget != NULL )

    		{

    		delete iSyncTarget;

    		iSyncTarget = NULL;

    		}

		if ( iCallTarget != NULL )

		    {

		    delete iCallTarget;

		    iCallTarget = NULL;

		    }

        if ( iCmdReceiverFromStub != NULL)

    	    {

    	    iCmdReceiverFromStub->Cancel();

    		delete iCmdReceiverFromStub;

    		iCmdReceiverFromStub = NULL;

    		}    	    			    

        if ( iTargetInterfaceSelector != NULL )

	    	{

	    	delete iTargetInterfaceSelector;

	    	iTargetInterfaceSelector = NULL;

	    	}

        if ( iAudioClientProc.Handle() )

            {

            iAudioClientProc.Kill( KErrNone );

            }

        //Just increase test coverage!

	    User::After(1000000);

	    COMPONENT_TRACE( ( _L( "CRemConControl::Finalize() - Success" ) ) );

	    }

void CRemConControl::DeleteInstances( void )

    {

    COMPONENT_TRACE( ( _L( "CRemConControl::Finalize()" ) ) );

		if ( iPocTarget != NULL )

    		{

    		delete iPocTarget;

    		iPocTarget = NULL;

    		}

		if ( iCoreTarget != NULL )

    		{

    		delete iCoreTarget;

    		iCoreTarget = NULL;

    		}

		if ( iSyncTarget != NULL )

    		{

    		delete iSyncTarget;

    		iSyncTarget = NULL;

    		}

		if( iCallTarget != NULL )

		    {

		    delete iCallTarget;

		    iCallTarget = NULL;

		    }

	    }

// This method calls API of module under test.

void CRemConControl::CallApiFunctionL( TRemConControlTestCaseState& aParameter )

    {

    //COMPONENT_TRACE( ( _L( "CRemConControl::CallApiFunctionL(%d, %d, %d)" ), aParameter.iDosFunction, aParameter.iArg1, aParameter.iArg2 ) );

    TInt retval = KTFErrRemConEventMissing;

    switch ( aParameter.iFunction )

        {

       	case ETFRemConEvent_NormalHandler:

            	{

            	    SwapToNormalHandlerL();

    				retval = KErrNone;

    			break;

            	}

    	case ETFRemConEvent_CmdHandler:

            	{            	 

    				retval = KErrNone;

    			break;

            	}

        case ETFRemCon_Subscribe:

        	{

		    	TPckgBuf<TRemConStubPSData> keyDatabuf;		

		    	TRemConStubPSData psData;

				psData.iKeyEvent     = aParameter.iKeyEvents;

				psData.iOperationId  = aParameter.iArg1;

				psData.iData.Copy( aParameter.iArg2 );

				psData.iUseConverter = aParameter.iUseConverter;

				keyDatabuf = psData;

	    		retval = iSubscribe.Set(KTFRemConTestProperty, KTFRemConTriggerCmdKey,keyDatabuf);

	    		retval = KErrNone;

	  		break;

        	}         

        case ETFRemCon_NotifyCommandSubscribe:

        	{

		    	TPckgBuf<TRemConStubPSData> keyDatabuf;		

		    	TRemConStubPSData psData;

				psData.iKeyEvent     = aParameter.iKeyEvents;

				psData.iOperationId  = aParameter.iArg1;

				psData.iData.Copy( aParameter.iArg2 );

				psData.iUseConverter = aParameter.iUseConverter;

				keyDatabuf = psData;

	    		retval = RProperty::Set(KTFRemConTestProperty, KTFRemConTriggerNotifyCmdKey,keyDatabuf);

	    		retval = KErrNone;

	  		break;

        	}             

		case ETFRemCon_PocButtonDownResponse:

        	{

				iPocTarget->APOCButtonDownResponse();

				retval = KErrNone;

			break;

        	}

		case ETFRemCon_PocButtonUpResponse:

        	{

				iPocTarget->APOCButtonUpResponse();

				retval = KErrNone;

			break;

        	}

		case ETFRemCon_SyncButtonResponse:

        	{

        		iSyncTarget->SynchronizeResponse();				

        		retval = KErrNone;				

			break;

        	}

       	case ETFRemCon_AddressOutgoingCommand:

        	{

        		iCoreTarget->Play();				

        		retval = KErrNone;				

			break;

        	}

       	case ETFRemCon_PermitOutgoingCommand:

        	{        	

        		iCoreTarget->Stop();				

        		retval = KErrNone;				

			break;

        	}

       	case ETFRemCon_CancelOutgoingCommand:

        	{        	

        		iCoreTarget->Cancel();				        		

        		retval = KErrNone;				

			break;

        	}

       	case ETFRemConEvent_CheckEvent:

        	{   

        	    retval = KErrNone;

        		if( aParameter.iExpectedKeyEvent != iKeyEvent )

        		    {

        		    retval = KErrNotFound;

        		    }

                if( aParameter.iArg1 != iParameter )

                    {

                    retval = KErrArgument;

                    }

                ResetEventResult();                    

			break;

        	}

        case ETFRemConEvent_CheckResponse:

        	{        	

        		retval = KErrNone;

        		if( aParameter.iExpectedKeyEvent != iKeyEvent )

        		    {

        		    retval = KErrNotFound;

        		    }

                if( aParameter.iArg1 != iParameter )

                    {

                    retval = KErrArgument;

                    }

                if( iError != KErrNone )    

                    {

                    retval = iError;

                    }

                ResetEventResult();                    

			break;

        	}

        case ETFRemConEvent_CheckOutgoingCommandResponse:

        	{        	

        		retval = KErrNone;

        		if( aParameter.iExpectedKeyEvent != iKeyEvent && iKeyEvent != ETFRemConEvent_CoreApiPlaybackSpeedX1 )

        		    {

        		    retval = KErrNotFound;

        		    }

                if( aParameter.iArg1 != iParameter && iParameter != ERemConCoreApiButtonClick )

                    {

                    retval = KErrArgument;

                    }

                if( iError != KErrNone )    

                    {

                    retval = iError;

                    }

                ResetEventResult();                    

			break;

        	}

        case ETFRemConEvent_CheckCmdSource:

            {

            TRemConExtCmdSource source;

            retval = KErrNone;

            iPocTarget->GetCommandSourceInfo( source );

            switch( source )

                {

                case ERemConExtCmdSourceBluetooth:

                    {

                    COMPONENT_TRACE( ( _L( "CRemConControl::CallApiFunctionL() ETFRemConEvent_CheckCmdSource - Bluetooth" ) ) );

                    break;

                    }

                case ERemConExtCmdSourceWired:

                    {

                    COMPONENT_TRACE( ( _L( "CRemConControl::CallApiFunctionL() ETFRemConEvent_CheckCmdSource - Wired" ) ) );

                    break;

                    }

                default:

                    {

                    COMPONENT_TRACE( ( _L( "CRemConControl::CallApiFunctionL() ETFRemConEvent_CheckCmdSource - UnKnown" ) ) );

                    break;

                    }

                }

            if( aParameter.iArg1 != source )

                {

                retval = KErrGeneral;

                }

            // For coverage

            if( retval == KErrNone )

            {

            	iCallTarget->GetCommandSourceInfo( source );

	            if( source != ERemConExtCmdSourceUnKnown )

	              {

	              retval = KErrGeneral;

	              }

            }

            if( retval == KErrNone )

            {

	            iSyncTarget->GetCommandSourceInfo( source );

	            if( source != ERemConExtCmdSourceUnKnown )

	              {

	              retval = KErrGeneral;

	              }

            }

            break;

            }

        	case ETFRemConEvent_SetCallState:

        	{        	

        		retval = iSubscribe.Set(KPSUidCtsyCallInformation, KCTsyCallState, aParameter.iArg1);

        		retval = KErrNone;				

			break;

        	}

        case ETFRemConEvent_LoadPCH_NoAccFW:

        	{

        	if( !iTargetInterfaceSelector )

        		{

        		iTargetInterfaceSelector = CRemConInterfaceSelector::NewL();

        		}        	        		

        	retval = KErrNone;

        	}

        	break;                

        case ETFRemCon_LaunchAudioClient:

            // reset return channel

            TRemConClientKeyDataBuf keyDatabuf;     

            TRemConClientKeyData keyData;

            keyData.iOperationId = ERemConCoreApiSelect; // if not changed by audio client maps to ETRemConEvent_None 

            keyData.iButtonAct = ERemConCoreApiButtonPress; 

            keyDatabuf = keyData;

            retval = RProperty::Set( KTFRemConTestProperty, KTFRemConClientKey, keyDatabuf );

            if ( retval == KErrNone )

                {

                retval = iAudioClientProc.Create( _L("audioclientstub.exe"), KNullDesC );

                // wait for start

                if ( retval == KErrNone )

                    {

                    TRequestStatus status;

                    iAudioClientProc.Rendezvous( status );

                    iAudioClientProc.Resume();

                    User::WaitForRequest( status );

                    retval = status.Int();

                    }

                }

            break;

        case ETFRemCon_CloseAudioClient:

            if ( iAudioClientProc.Handle() )

                {

                iAudioClientProc.Kill( KErrNone );

                retval = KErrNone;

                }

            break;

        case ETFRemCon_CheckClientKey:

            TRemConClientKeyDataBuf keyDataBuf;

            retval = RProperty::Get( KTFRemConTestProperty, KTFRemConClientKey, keyDataBuf );

            if ( retval == KErrNone )

                {

                if ( aParameter.iExpectedKeyEvent != MapRemConToTfKey( keyDataBuf().iOperationId ) )

                    {

                    retval = KErrNotFound;

                    }

                if( aParameter.iArg1 != keyDataBuf().iButtonAct )

                    {

                    retval = KErrArgument;

                    }

                }

            break;

        default:

	        //TRACE_ASSERT_FALSE();

            break;