/*

* Copyright (c) 2007 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:  Hardware Resource Manager stub plugins fmtx plugin 

*                implementation.

*

*/

#include <hwrmfmtxcommands.h>

#include "FmtxPlugin.h"

#include "PluginTimer.h"

#include "Trace.h"

const TUint32 KFmTxStubPluginFreqMax  = 107900; // KHz

const TUint32 KFmTxStubPluginFreqMin  = 88100; // KHz

const TUint32 KFmTxStubPluginStepSize = 50; // KHz

const TInt KMaxLengthMarker = 63;

#ifdef PUBLISH_STATE_INFO

const TUid KPSUidHWResourceNotification = {0x101F7A01}; // HWRM private PS Uid

#endif /* PUBLISH_STATE_INFO */

CFmtxPlugin* CFmtxPlugin::NewL()

    {

    COMPONENT_TRACE(( _L("CFmtxPlugin::NewL()") ));

    CFmtxPlugin* self = new(ELeave) CFmtxPlugin();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CFmtxPlugin::~CFmtxPlugin()

    {

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

    iTimers.ResetAndDestroy();

#ifdef PUBLISH_STATE_INFO

    iCmdProperty.Close();

    iDataProperty.Close();

#endif /* PUBLISH_STATE_INFO */

    }

CFmtxPlugin::CFmtxPlugin() : iLastCommand(HWRMFmTxCommand::ENoCommandId),

                             iHwState(HWRMFmTxCommand::EFmTxHwStateOff),

                             iClearFrequency(KFmTxStubPluginFreqMin)

    {

    COMPONENT_TRACE(( _L("CFmtxPlugin::CFmtxPlugin()") ));

    }

void CFmtxPlugin::ConstructL()

    {

    COMPONENT_TRACE(( _L("CFmtxPlugin::ConstructL") ));

#ifdef PUBLISH_STATE_INFO

    RProperty::Define(KPSUidHWResourceNotification, KHWRMTestFmtxCommand, RProperty::EInt);

    RProperty::Define(KPSUidHWResourceNotification, KHWRMTestFmtxDataPckg, RProperty::EByteArray, 512);

    iCmdProperty.Attach(KPSUidHWResourceNotification, KHWRMTestFmtxCommand);

    iDataProperty.Attach(KPSUidHWResourceNotification, KHWRMTestFmtxDataPckg);

#endif /* PUBLISH_STATE_INFO */

    }

TInt CFmtxPlugin::CheckFrequencyWithinRange(TDesC8& aData)

	{

	HWRMFmTxCommand::TSetFrequencyPackage pckg;

	pckg.Copy(aData);

	TInt frequency = pckg();

	if ( frequency < KFmTxStubPluginFreqMin ||

		 frequency > KFmTxStubPluginFreqMax )

		{

		COMPONENT_TRACE((_L("CFmtxPlugin::CheckFrequencyWithinRange, frequency %d is out of range"), frequency));

		return KErrArgument;

		}

	else

		{

		iFrequency = frequency;

		return KErrNone;

		}

	}

void CFmtxPlugin::ProcessCommandL(const TInt aCommandId,

                                  const TUint8 aTransId,

                                  TDesC8& aData)

    {

    COMPONENT_TRACE((_L("CFmtxPlugin::ProcessCommandL, command: 0x%x, TransId: 0x%x"), aCommandId, aTransId));

    TInt retVal(KErrNone);

    switch (aCommandId)

        {

        case HWRMFmTxCommand::ETxOnCmdId:

            {

            COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ETxOnCmdId"));

            // check TSetFrequencyPackage param

			if ( iHwState != HWRMFmTxCommand::EFmTxHwStateOff )

				{

				retVal = KErrInUse;

				}

			else

			    {

			    retVal = CheckFrequencyWithinRange(aData);

			    }

			}

            break;

        case HWRMFmTxCommand::ETxOffCmdId:

            {

            COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ETxOffCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOff )

				{

				retVal = KErrNotReady;

				}

            }

            break;

        case HWRMFmTxCommand::ESetTxFrequencyCmdId:

            {

            COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxFrequencyCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

            	// check TSetFrequencyPackage param

				retVal = CheckFrequencyWithinRange(aData);

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}			

            }

            break;

        case HWRMFmTxCommand::ETxScanRequestCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ETxScanRequestCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{        	

        		// check TScanRequestPackage param        	

        		HWRMFmTxCommand::TScanRequestPackage pckg;

				pckg.Copy(aData);        	

				TUint channelsRequested = pckg();			

                if( channelsRequested > 10 )

                    {

                    // Should not come here because input verified in client end

                    retVal = KErrArgument;

                    }

				iChannelsRequested = ( channelsRequested <= 10 ) ? channelsRequested : 10;

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}

        	}

        	break;

        case HWRMFmTxCommand::EGetTxFrequencyRangeCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed EGetTxFrequencyRangeCmdId"));

        	// No params to check

        	}

        	break;        

        case HWRMFmTxCommand::ESetTxRdsPsCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxRdsPsCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

				// check TRdsPsPackage param

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}

        	}

        	break;        

        case HWRMFmTxCommand::ESetTxRdsPtyCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxRdsPtyCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

				// Check TRdsPtyPackage param

        		HWRMFmTxCommand::TRdsPtyPackage pckg;

				pckg.Copy(aData);        	

				TInt programType = pckg();			

                const TInt KRdsPtyFirst = 0;

                const TInt KRdsPtyLast = 31;

                if( programType < KRdsPtyFirst || programType > KRdsPtyLast )

                    {

                    // Should not come here because input verified in client end

                    retVal = KErrArgument;

                    }

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}        	

        	}

        	break;        	        

        case HWRMFmTxCommand::ESetTxRdsPtynCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxRdsPtynCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

        		// Check TRdsPtynPackage param

        		HWRMFmTxCommand::TRdsPtynPackage pckg;

				pckg.Copy(aData);        	

				HWRMFmTxCommand::TRdsPtyn prgTypeName = pckg();			

                const TInt KMaxRdsPtynLength = 8;

                if( prgTypeName.Length() > KMaxRdsPtynLength )

                    {

                    // Should not come here because input verified in client end

                    retVal = KErrArgument;

                    }

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}        	

        	}

        	break;

        case HWRMFmTxCommand::ESetTxRdsMsCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxRdsMsCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

        		// No params to check

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}         	

        	}

        	break;        

        case HWRMFmTxCommand::ESetTxRdsLangIdCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxRdsLangIdCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

        		// Check TRdsLangIdPackage param

        		HWRMFmTxCommand::TRdsLangIdPackage pckg;

				pckg.Copy(aData);        	

				TInt languageId = pckg();

                const TInt KRdsLanguageFirst = 0x00;

                const TInt KRdsLanguageLast = 0x7F;

                if( languageId < KRdsLanguageFirst || languageId > KRdsLanguageLast )

                    {

                    // Should not come here because input verified in client end

                    User::Leave(KErrArgument);

                    }

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}           	

        	}

        	break;        

        case HWRMFmTxCommand::ESetTxRtCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed ESetTxRtCmdId"));

			if ( iHwState == HWRMFmTxCommand::EFmTxHwStateOn )

				{

        		// Check TRtPackage params

	            HWRMFmTxCommand::TRtPackage pckg;

	            pckg.Copy(aData);

                HWRMFmTxCommand::TRtData rtData = pckg();

	            if( rtData.iTag1.iContentType > KMaxLengthMarker || rtData.iTag2.iContentType > KMaxLengthMarker ||

                    rtData.iTag1.iLengthMarker > KMaxLengthMarker || rtData.iTag2.iLengthMarker > KMaxLengthMarker )

                    {

                    retVal = KErrArgument;

                    }

				}

			else

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}            	

        	}

        	break;        

        case HWRMFmTxCommand::EClearTxRtCmdId:

        	{

        	COMPONENT_TRACE(_L("HWRM FmtxPlugin: Processed EClearTxRtCmdId"));

			if ( iHwState != HWRMFmTxCommand::EFmTxHwStateOn )			

				{

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: HW isn't ready, iHwState = %d"), iHwState));

				retVal = KErrNotReady;

				}             	        	

			// No params to check

        	}

        	break;

		case HWRMFmTxCommand::ENoCommandId:   // fall through

        default :

            {

            COMPONENT_TRACE((_L("HWRM FmtxPlugin: Unknown Command: 0x%x"), aCommandId));

            }

            break;

        }

    // Check for concurrent requests. Scan request (ETxScanRequestCmdId) may precede

    // set frequency (ESetTxFrequencyCmdId), because it is handled as a split command.

    if ( iLastCommand != HWRMFmTxCommand::ENoCommandId &&

         !(iLastCommand == HWRMFmTxCommand::ETxScanRequestCmdId && aCommandId == HWRMFmTxCommand::ESetTxFrequencyCmdId) )

    	{

		COMPONENT_TRACE(_L("HWRM FmtxPlugin: Not ready due to concurrent command"));

    	retVal = KErrNotReady;

    	}

	iLastCommand = static_cast<HWRMFmTxCommand::TFmTxCmd>(aCommandId);

    TInt timeout(500); // microseconds

    // Increase timeout for scan requests

    if (HWRMFmTxCommand::ETxScanRequestCmdId == aCommandId)

    	{

    	timeout = 2*1000*1000; // 2 seconds

    	}

#ifdef PUBLISH_STATE_INFO

    // publish

    iCmdProperty.Set(aCommandId);

    iDataProperty.Set(aData);

#endif /* PUBLISH_STATE_INFO */

    // create new timer

    CPluginTimer* timer = CPluginTimer::NewL(timeout, iResponseCallback, aCommandId, aTransId, retVal, this);

    CleanupStack::PushL(timer);

    iTimers.AppendL(timer);

    CleanupStack::Pop(timer);

    COMPONENT_TRACE((_L("HWRM FmtxPlugin: Processing command - return")));

    }

void CFmtxPlugin::CancelCommandL(const TUint8 aTransId,

#if defined(_DEBUG) && defined(COMPONENT_TRACE_FLAG)

                                 const TInt aCommandId)

#else

                                 const TInt /*aCommandId*/)

#endif

    {

    COMPONENT_TRACE((_L("HWRM FmtxPlugin: Cancelling command: 0x%x, TransId: 0x%x"), aCommandId, aTransId));

    COMPONENT_TRACE((_L("HWRM FmtxPlugin: Cancelling command - iTimers.Count(): %d "), iTimers.Count()));

    for( TInt i = 0; i < iTimers.Count(); i++ )

        {

        if ( iTimers[i]->TransId() == aTransId )

            {

            delete iTimers[i];

            iTimers.Remove(i);

            COMPONENT_TRACE((_L("HWRM FmtxPlugin: Cancelling command - Removed command: 0x%x, TransId: 0x%x"), aCommandId, aTransId));

            break;

            }

        }

    if ( iTimers.Count() == 0 )

    	{

    	// no more commands on-going

    	iLastCommand = HWRMFmTxCommand::ENoCommandId;

    	}

    }

void CFmtxPlugin::GenericTimerFired(MHWRMPluginCallback* aService,

                                    TInt aCommandId,

                                    const TUint8 aTransId,

                                    TInt aRetVal)

    {

    COMPONENT_TRACE((_L("HWRM FmtxPlugin: GenericTimerFired (0x%x, 0x%x, %d)"), aCommandId, aTransId, aRetVal));

    __ASSERT_ALWAYS(aService != NULL, User::Invariant() );

	TInt err = KErrNone;

	HWRMFmTxCommand::TFmTxHwState tempState = HWRMFmTxCommand::EFmTxHwStateOff;

    switch (aCommandId)

        {

        case HWRMFmTxCommand::EGetTxFrequencyRangeCmdId:

        	{

			COMPONENT_TRACE((_L("HWRM FmtxPlugin: Returning freq range")));

			HWRMFmTxCommand::TFrequencyRangeData freqRange;

			freqRange.iErrorCode = KErrNone;

			freqRange.iMinFrequency = KFmTxStubPluginFreqMin;

			freqRange.iMaxFrequency = KFmTxStubPluginFreqMax;

			freqRange.iStepSize = KFmTxStubPluginStepSize;

    		HWRMFmTxCommand::TFrequencyRangePackage freqRangePckg(freqRange);

    		TRAP(err, aService->ProcessResponseL(aCommandId, aTransId, freqRangePckg)); 

        	}

        	break;

        case HWRMFmTxCommand::ETxScanRequestCmdId:

        	{

			HWRMFmTxCommand::TScanResponseData scanData;

			scanData.iErrorCode = aRetVal;

			if ( aRetVal == KErrNone )

				{

				if ( (iClearFrequency += KFmTxStubPluginStepSize) > KFmTxStubPluginFreqMax )

					{

					iClearFrequency = KFmTxStubPluginFreqMin;

					}

				scanData.iErrorCode = KErrNone;

    			scanData.iFrequenciesFound = iChannelsRequested;

    			TUint32 clearFrequency = iClearFrequency;

    			for(TInt i=0; i<iChannelsRequested; i++)

    			    {

    			    scanData.iChannels.Copy(&clearFrequency,i+1);

    				if ( (clearFrequency += KFmTxStubPluginStepSize) > KFmTxStubPluginFreqMax )

    					{

    					clearFrequency = KFmTxStubPluginFreqMin;

    					}

    			    }

    			COMPONENT_TRACE((_L("HWRM FmtxPlugin: Returning 1 clear frequency")));

				}

			else

				{

				scanData.iFrequenciesFound = 0;

				COMPONENT_TRACE((_L("HWRM FmtxPlugin: Returning 0 clear frequencies")));

				}			

    		HWRMFmTxCommand::TScanResponsePackage scanPckg(scanData);

    		TRAP(err, aService->ProcessResponseL(aCommandId, aTransId, scanPckg)); 

    		}

        	break;

        case HWRMFmTxCommand::ETxOnCmdId:           // fall through

        case HWRMFmTxCommand::ESetTxFrequencyCmdId: 

        	tempState = HWRMFmTxCommand::EFmTxHwStateOn; // fall through

        case HWRMFmTxCommand::ETxOffCmdId:          

        	{

        	if ( aRetVal == KErrNone)

        		{

        		iHwState = tempState;

				if ( iStatusIndTransId ) // if request successful, and status indication has been requested

	        		{	

    	    		// also send frequency/state changed indications for these

 					COMPONENT_TRACE((_L("HWRM FmtxPlugin: sending status indication")));

 					HWRMFmTxCommand::TFmTxStatusData statusData;

 					statusData.state     = tempState;

					statusData.frequency = iFrequency;

		    		HWRMFmTxCommand::TStatusIndicationPackage statusIndPckg(statusData);

		    		TInt tempTransId = iStatusIndTransId; // status indication may be reissued immediately...

	    			iStatusIndTransId = 0;                // ...so null here first

					TRAP(err, aService->ProcessResponseL(HWRMFmTxCommand::ETxStatusIndId, tempTransId, statusIndPckg)); 

					if ( err != KErrNone )

						{

						COMPONENT_TRACE((_L("HWRM FmtxPlugin: Error sending status indication")));

						}

					}

				}

        	} // fall through

        case HWRMFmTxCommand::ESetTxRdsPsCmdId:

        case HWRMFmTxCommand::ESetTxRtCmdId:

        default :

            {

            COMPONENT_TRACE((_L("HWRM FmtxPlugin: Returning error code %d, Command: 0x%x"), aRetVal, aCommandId));

    		HWRMFmTxCommand::TErrorCodeResponsePackage retvalPackage(aRetVal);

    		TRAP(err, aService->ProcessResponseL(aCommandId, aTransId, retvalPackage));          

            }

            break;

        }

    if ( err != KErrNone )

        {

        COMPONENT_TRACE((_L("HWRM FmtxPlugin: Error in ProcessResponseL: %d"), err));

        }

    // delete obsolete timers

    for( TInt i = (iTimers.Count()-1); i > -1 ; i-- )

        {

        if ( !iTimers[i]->IsActive() )

            {

            delete iTimers[i];

            iTimers.Remove(i);

            COMPONENT_TRACE((_L("HWRM FmtxPlugin: GenericTimerFired - Removed obsolete timer")));

            }

        }

    if ( iTimers.Count() == 0 )

    	{

    	// no more commands on-going

    	iLastCommand = HWRMFmTxCommand::ENoCommandId;

    	}

    }