// Copyright (c) 2006-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 FILES

#include "HWRMServer.h"

#include "HWRMService.h"

#include "HWRMFmTxService.h"

#include "HWRMPluginHandler.h"

#include "HWRMReservationHandler.h"

#include "HWRMFmTxCommands.h"

#include "HWRMFmTxClientServer.h"

#include "HWRMFmTxRdsTextConverter.h"

#include "HWRMtrace.h"

// CONSTANTS

_LIT( KPanicCategory, "HWRMFmTxService" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CHWRMFmTxService::CHWRMFmTxService

// C++ constructor

// -----------------------------------------------------------------------------

//

CHWRMFmTxService::CHWRMFmTxService(CHWRMPluginHandler& aWatcherPluginHandler,

                                   CHWRMFmTxCommonData& aFmTxCommonData, 

                                   CHWRMFmTxRdsTextConverter& aRdsTextConverter)

    : iWatcherPluginHandler(aWatcherPluginHandler),

      iFmTxCommonData(aFmTxCommonData), 

      iRdsTextConverter(aRdsTextConverter)

    {

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::CHWRMFmTxService()" ));

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::CHWRMFmTxService - return" ));

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CHWRMFmTxService::ConstructL(CHWRMPluginHandler* aPluginHandler,

                                  CHWRMReservationHandler* aReservationHandler)

    {

    COMPONENT_TRACE3( _L( "HWRM Server - CHWRMFmTxService::ConstructL(0x%x, 0x%x)" ), aPluginHandler, aReservationHandler);

    __ASSERT_ALWAYS(aPluginHandler, User::Panic(KPanicCategory, EPanicBadHandle));

    __ASSERT_ALWAYS(aReservationHandler, User::Panic(KPanicCategory, EPanicBadHandle));

    BaseConstructL(aPluginHandler, aReservationHandler);

    iWatcherTransactionList = CHWRMPluginTransactionList::NewL();

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::ConstructL - return " ) );

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CHWRMFmTxService* CHWRMFmTxService::NewL(CHWRMPluginHandler* aPluginHandler,

										 CHWRMPluginHandler& aWatcherPluginHandler,

                                         CHWRMReservationHandler* aReservationHandler,

                                         CHWRMFmTxCommonData& aFmTxCommonData,

                                         CHWRMFmTxRdsTextConverter& aRdsTextConverter)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::NewL(0x%x)" ), aPluginHandler);

    CHWRMFmTxService* self = new( ELeave ) 

    				CHWRMFmTxService(aWatcherPluginHandler, aFmTxCommonData, aRdsTextConverter);

    CleanupStack::PushL( self );

    self->ConstructL(aPluginHandler, aReservationHandler);

    CleanupStack::Pop( self );

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::NewL - return 0x%x" ), self );

    return self;

    }

// ---------------------------------------------------------

// Destructor

// ---------------------------------------------------------

//

CHWRMFmTxService::~CHWRMFmTxService()

    {

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::~CHWRMFmTxService()" ) );

    DoRelease();

    // Base class cleanup

    BaseDestruct();

    // Complete any pending watchertransaction requests

    while ( iWatcherTransactionList->GetFirstItem() )

        {

        THWRMPluginRequestData* data = static_cast<THWRMPluginRequestData*>( 

                                            iWatcherTransactionList->RemoveFirstItem() );

        if (data->iRequestMessage.Handle())

            {

            COMPONENT_TRACE1( ( _L( "HWRM Server - CHWRMService::~CHWRMFmTxService() - Canceling pending message" ) ) );

            data->iRequestMessage.Complete(KErrCancel);

            }

        TRAPD(err, iWatcherPluginHandler.CancelCommandL(data->iTransId));

        if ( err != KErrNone )

            {

            COMPONENT_TRACE3( _L( "HWRM Server - CHWRMService::~CHWRMFmTxService - Cancelling Command (transid: %d) failed: %d" ), data->iTransId, err );

            }

        delete data;

        }

    // Destroy watchertransaction list

    delete iWatcherTransactionList;

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::~CHWRMFmTxService - return" ) );

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::ExecuteMessageL

// Handles FM Tx requests.  Called from the client session via CSession2::ServiceL

// -----------------------------------------------------------------------------

//

TBool CHWRMFmTxService::ExecuteMessageL( const RMessage2& aMessage )

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::ExecuteMessageL(0x%x)" ), aMessage.Function());

    if ( aMessage.IsNull() )

        {

        User::Leave(KErrBadHandle);

        }

    // All messages are by default asynchronous because of the nature of the plugin API

    TBool completeMessage(EFalse);

    switch ( aMessage.Function() )

        {

        case EHWRMFmTxCleanup:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxCleanup") );

            DoRelease();        

            completeMessage = ETrue;

            }

            break;

        case EHWRMFmTxOn:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxOn") );

            EnableL( aMessage );

            }

            break;

        case EHWRMFmTxOff:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxOff") );

            completeMessage = DisableL( aMessage );

            }

            break;

        case EHWRMFmTxGetFreqRange:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxGetFreqRange") );

            GetFrequencyRangeL( aMessage );

            }

            break;

        case EHWRMFmTxSetFreq:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetFreq") );              

            completeMessage = SetFrequencyL( aMessage );

            }

            break;

        case EHWRMFmTxReserve:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxReserve") );

            // If returned mask is non-zero, reservation was done in suspended mode.

            iSuspended = (iReservationHandler->ReserveL(aMessage, aMessage.Int1(), this, KHWRMAllSubResources));

            iReserved = ETrue;

            completeMessage = ETrue; // Complete needed, as dummy used.             

            }

            break;

        case EHWRMFmTxRelease:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxRelease") );

            DoRelease();

            completeMessage = ETrue; // Complete needed, as dummy used.             

            }

            break;          

        case EHWRMFmTxGetNextClearFreq:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxGetNextClearFreq") );

            GetNextClearFrequencyL( aMessage,

                                    1/*1 clear frequency required*/ );

            }

            break;      

        case EHWRMFmTxGetNextClearFreqArray:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxGetNextClearFreqArray") );

            TPckgBuf<TUint> clientClearFreqCountPckg;

            aMessage.ReadL(1,clientClearFreqCountPckg);

            GetNextClearFrequencyL( aMessage,

                                    clientClearFreqCountPckg() /*number of clear frequencies required*/ );

            }

            break;      

        case EHWRMFmTxCancelGetNextClearFreq:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxCancelGetNextClearFreq") );

            CancelPluginCommandL( HWRMFmTxCommand::ETxScanRequestCmdId );

            completeMessage = ETrue; // no responses from plugin cancel commands

            }

            break;

        case EHWRMFmTxSetNextClearFreq:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetNextClearFreq") );

            SetNextClearFrequencyL( aMessage,

                                    1/*1 clear frequency required*/ );

            }

            break;  

        case EHWRMFmTxCancelSetNextClearFreq:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxCancelSetNextClearFreq") );

            // no hope of cancelling the ESetTxFrequencyCmdId part, so try the ETxScanRequestCmdId

            CancelPluginCommandL( HWRMFmTxCommand::ETxScanRequestCmdId );

            completeMessage = ETrue; // no responses from plugin cancel commands

            }

            break;        

        case EHWRMFmTxSetRdsPty:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRdsPty") );

            SetRdsPtyL( aMessage );

            }

            break;

        case EHWRMFmTxSetRdsPtyn:        

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRdsPtyn") );

            SetRdsPtynL( aMessage );

            }

            break;

        case EHWRMFmTxSetRdsMs:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRdsMs") );

            SetRdsMsL( aMessage );

            }

            break;

        case EHWRMFmTxSetRdsLanguageId:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRdsLanguageId") );

            SetRdsLanguageIdL( aMessage );

            }

            break;

        case EHWRMFmTxSetRadiotext:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRadiotext") );

            SetRadiotextL( aMessage );

            }

            break;

        case EHWRMFmTxSetRadiotextPlus1:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRadiotext") );             

            TRtPlusTag tag; // create a RT tag

            tag.iContentType  = (TRtPlusContentType)aMessage.Int1();

            tag.iStartMarker  = 0;

            tag.iLengthMarker = aMessage.GetDesLengthL(0);  

            SetRadiotextL( aMessage, tag );

            }

            break;

        case EHWRMFmTxSetRadiotextPlus2:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRadiotext") );

            // read RT tag from client

            THWRMRtPlusTagCmdPackage tagPckg;

            if ( aMessage.Read(1, tagPckg) != KErrNone )

                {

                User::Leave(KErrArgument);

                }

            TRtPlusTag tag = tagPckg();

            SetRadiotextL( aMessage, tag );  

            }

            break;

        case EHWRMFmTxSetRadiotextPlus3:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxSetRadiotext") );

            // read RT tags from client

            THWRMRtPlusTagCmdPackage tagPckg1, tagPckg2;

            if ( aMessage.Read(1, tagPckg1) != KErrNone ||

                 aMessage.Read(2, tagPckg2) != KErrNone )

                {

                User::Leave(KErrArgument);

                }

            TRtPlusTag tag1 = tagPckg1();

            TRtPlusTag tag2 = tagPckg2();

            SetRadiotextL( aMessage, tag1, tag2 );

            }

            break;

        case EHWRMFmTxClearRdsData:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxClearRdsData") );

            ClearRdsDataL( aMessage );

            }

            break;

        case EHWRMFmTxClearRtData:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMFmTxService::ExecuteMessageL - EHWRMFmTxClearRtData") );

            ClearRadiotextDataL( aMessage );

            }

            break;

        // Not currently supported

        case EHWRMFmTxAutoFreqOn:

        case EHWRMFmTxAutoFreqOff:

            {

            User::Leave(KErrNotSupported);

            }

            break;

        // Cannot identify the message, panic the client

        default:

            {

            CHWRMServer::PanicClient(aMessage, EPanicIllegalFunction);

            }

            break;

        }

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::ExecuteMessageL - return 0x%x" ), completeMessage );

    return completeMessage;

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::EnableL

// Sends a plug-in command to switch FM Tx ON

// -----------------------------------------------------------------------------

//

void CHWRMFmTxService::EnableL(const RMessage2& aMessage)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::EnableL(0x%x)" ), aMessage.Int0() );

    LeaveIfOtherReservationL();

    // We cannot enable from "power save" state

    if ( iFmTxCommonData.IsAccessoryPowerSaveOn() )

        {

		// We cannot enable during "power save" due to mutually exclusive accessory connection.			

        COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::EnableL - not ready in \"power save\" state" ) );

        User::Leave(KErrNotReady);

        }

    else if ( iFmTxCommonData.IsFmTxHardwareOn() )

        {

        // If already On, then send the new frequency instead

        COMPONENT_TRACE1( ( _L( "HWRM Server - CHWRMFmTxService::EnableL - HW already on" ) ) ); 

        HWRMFmTxCommand::TSetFrequencyPackage pckg( aMessage.Int0() );

        ExecutePluginCommandL(aMessage, HWRMFmTxCommand::ESetTxFrequencyCmdId, EFalse/*not split*/, pckg, aMessage.Int0() );

        }

    else

        {

        //start observing       

        ExecutePluginCommandL(aMessage, HWRMFmTxCommand::EStartObservingCmdId, EFalse/*not split*/ );

        iFmTxCommonData.UpdateFrequency( aMessage.Int0() );

        }

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::EnableL - return" ) );

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::DisableL

// Sends a plug-in command to switch FM Tx OFF

// -----------------------------------------------------------------------------

//

TBool CHWRMFmTxService::DisableL(const RMessage2& aMessage)

    {

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::DisableL" ) );

    LeaveIfOtherReservationL();

    // We don't need to disable HW from some states

	if ( !iFmTxCommonData.IsFmTxHardwareOn() )

        {

        COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::DisableL - HW already off due to power-save mode" ) );

        iFmTxCommonData.UpdateStatus(CHWRMFmTxCommonData::EFmTxStateTransRequestedOff);

        return ETrue;

        }

    ExecutePluginCommandL(aMessage, HWRMFmTxCommand::ETxOffCmdId, EFalse/*not split*/ );

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::DisableL - return" ) );

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::GetFrequencyRangeL

// Sends a plug-in command to query the FM Tx frequency range

// -----------------------------------------------------------------------------

//

void CHWRMFmTxService::GetFrequencyRangeL(const RMessage2& aMessage)

    {

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::GetFrequencyRangeL" ) );

    ExecutePluginCommandL(aMessage, HWRMFmTxCommand::EGetTxFrequencyRangeCmdId, EFalse/*not split*/ );

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::GetFrequencyRangeL - return" ) );

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::SetFrequencyL

// Sends a plug-in command to set the FM Tx frequency

// -----------------------------------------------------------------------------

//

TBool CHWRMFmTxService::SetFrequencyL(const RMessage2& aMessage)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::SetFrequencyL(0x%x)" ), aMessage.Int0() );

    LeaveIfOtherReservationL();

    TInt retVal = EFalse;

    // Check Tx status

    if ( iFmTxCommonData.IsFmTxHardwareOn() )

        {

        // Package & send the request

        HWRMFmTxCommand::TSetFrequencyPackage pckg( aMessage.Int0() );

        ExecutePluginCommandL(aMessage, HWRMFmTxCommand::ESetTxFrequencyCmdId, EFalse/*not split*/, pckg, aMessage.Int0() );

        retVal = EFalse; // don't complete message yet

        }

    else

        {

        // Just save the frequency for future use

        iFmTxCommonData.UpdateFrequency( aMessage.Int0() );

        retVal = ETrue; // complete message now

        }

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::SetFrequencyL - return %d" ), retVal );

    return retVal;

    }        

// -----------------------------------------------------------------------------

// CHWRMFmTxService::GetNextClearFrequencyL

// Sends a plug-in command to scan for an available (clear) frequency

// -----------------------------------------------------------------------------

//

void CHWRMFmTxService::GetNextClearFrequencyL(const RMessage2& aMessage,

                                              TUint aClearFreqsRequired)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::GetNextClearFrequencyL(%d)" ), aClearFreqsRequired );

    LeaveIfOtherReservationL();

    LeaveIfTransmitterOffL();

    // package up the request

    HWRMFmTxCommand::TScanRequestPackage pckg(aClearFreqsRequired);

    ExecutePluginCommandL(aMessage, HWRMFmTxCommand::ETxScanRequestCmdId, EFalse/*not split*/, pckg );

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::GetClearFrequencyL - return" ) ); 

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::SetNextClearFrequencyL

// Sends the 1st part of a split command, to scan for an available (clear) frequency

// -----------------------------------------------------------------------------

//

void CHWRMFmTxService::SetNextClearFrequencyL(const RMessage2& aMessage,

                                              TUint  aClearFreqsRequired)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMFmTxService::SetNextClearFrequencyL(%d)" ), aClearFreqsRequired );

    LeaveIfOtherReservationL();

    LeaveIfTransmitterOffL();

    // package up the request

    HWRMFmTxCommand::TScanRequestPackage pckg(aClearFreqsRequired);

    ExecutePluginCommandL(aMessage, HWRMFmTxCommand::ETxScanRequestCmdId, ETrue/*split*/, pckg );

    // wait until response before calling SetFrequencyL

    COMPONENT_TRACE1( _L( "HWRM Server - CHWRMFmTxService::SetNextClearFrequencyL - return" ) ); 

    }

// -----------------------------------------------------------------------------

// CHWRMFmTxService::SetRdsPtyL

// Sends a plug-in command to set the Programme TYpe

// -----------------------------------------------------------------------------

//

void CHWRMFmTxService::SetRdsPtyL(const RMessage2& aMessage)

    {