// 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 <e32svr.h>

#include <centralrepository.h>

#include <hwrm/hwrmfmtx.h>

#include "HWRMFmTxImpl.h"

#include "HWRMFmTxClientServer.h"

#include "HWRMtrace.h"

#include "HWRMFmTxStatusObserver.h"

#include "HWRMFmTxFrequencyObserver.h"

#include "HWRMFmTxInternalPSKeys.h"

#include "hwrmuipluginhandler.h"

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

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

// CHWRMFmTxImpl::CHWRMFmTxImpl

// C++ constructor

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

//

CHWRMFmTxImpl::CHWRMFmTxImpl() :

    iClearFrequencyPckg(NULL, 0, 0),

    iClearFrequencyCountPckg(NULL, 0, 0)

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::CHWRMFmTxImpl()" ) );

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::CHWRMFmTxImpl - return" ));

    }

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

// CHWRMFmTxImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMFmTxImpl::ConstructL(MHWRMFmTxObserver* aCallback)

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::ConstructL()" ) );

    // NULL is acceptable value for aCallback, just means that 

    // client is not interested in callbacks.

    iCallback = aCallback;

    // Connect the session and order notifications

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::ConstructL()" ));

    User::LeaveIfError(iClient.Connect(HWRMResourceTypeFmTx));

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::ConstructL - Ordering notifications" ) );

    iStatusObserver    = CHWRMFmTxStatusObserver::NewL(iCallback);

    iFrequencyObserver = CHWRMFmTxFrequencyObserver::NewL(iCallback);

    TInt err(KErrNone);    

	TRAP(err, iUiPluginHandler = CHwrmUiPluginHandler::NewL( ));

	if ( err != KErrNone )

    	{    	

    	COMPONENT_TRACE2(_L( "HWRM FM Tx Client - CHWRMFmTxImpl::ConstructL() - No Cone Plugin Handler" ), err );

    	iUiPluginHandler = NULL;

    	}

	if(iUiPluginHandler)

		{

			iUiPluginHandler->AddForegroundObserverL(this);    	

		}

	COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::ConstructL - return" ) );    

    }

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

// Destructor

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

//

CHWRMFmTxImpl::~CHWRMFmTxImpl()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::~CHWRMFmTxImpl()" ) );

    // close HWRM client, also deletes status observers

    Close();

    delete iUiPluginHandler;

    // iCallback is not owned so it is not cleaned, just set to NULL 

    iCallback = NULL;

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::~CHWRMFmTxImpl - return" ) );

    }

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

// CHWRMFmTxImpl::Close

// Closes session.

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

//

void CHWRMFmTxImpl::Close()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Close()" ));

    // Inform session that we are cleaning up now.

    // Ignore errors, just trace them

    TInt err(KErrNone);

    if (iClient.Handle())

        {

        err =iClient.ExecuteOperation(EHWRMFmTxCleanup, TIpcArgs());

        }

    if ( err != KErrNone )

        {

        COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Close - Error in cleanup: %d" ), err );

        }

    // Abort status/frequency notifications

    if ( iStatusObserver )

        {

        COMPONENT_TRACE1( _L( "HWRM FM Tx - CHWRMFmTxImpl::Close - canceling FM Tx Status notifications" ) );

        iStatusObserver->Cancel();

        delete iStatusObserver;

        iStatusObserver = NULL;

        }

    delete iFrequencyObserver;

    iFrequencyObserver = NULL;

    iClient.Close();

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Close - return" ) );

    }

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

// CHWRMFmTxImpl::ReserveL

// Handles client request to reserve FM Tx

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

//

void CHWRMFmTxImpl::ReserveL(TBool aForceNoCCoeEnv)

    {

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::ReserveL(0x%x)" ), aForceNoCCoeEnv);

    if ( !aForceNoCCoeEnv )

        {        

        if ( iUiPluginHandler )

            {

            // Check that we are on foreground (i.e. we have keyboard focus.)

            // Note: There can be windows on top of our application that have explicitly disabled keyboard focus,

            // but then again the foreground/background observer will not kick in in those cases either.

            // -> We can use focus to determine foreground status here.

            if ( iUiPluginHandler->InForeground() == EFalse )        

                {

                COMPONENT_TRACE1( ( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::ReserveL - Application does not have focus, Reserve denied." ) ) );

                User::Leave(KErrNotReady);

                }

            }

        else

            {

            COMPONENT_TRACE1(_L( "HWRM VibraClient - CHWRMFmTxImpl::::ReserveL - No iUiPluginHandler available" ) );

            User::Leave(KErrBadHandle);

            }

        }

    // Do the actual reservation

    DoReserveL(aForceNoCCoeEnv);

    COMPONENT_TRACE1(_L( "HWRM FM Tx Client - CHWRMFmTxImpl::ReserveL - return" ) );          

    }

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

// CHWRMFmTxImpl::Release

// Handles client request to release FM Tx

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

//  

void CHWRMFmTxImpl::Release()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Release()" ) );

    TInt err = DoRelease();

    if ( err != KErrNone )

        {

        COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Release - execution failed: %d" ), err );

        }

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Release - return" ) );  

    }

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

// CHWRMFmTxImpl::Status

// Returns current FM Tx state

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

//

TFmTxState CHWRMFmTxImpl::Status() const

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Status" ) );

    TFmTxState state = EFmTxStateUnknown;

    if ( iStatusObserver )

        {

        state = iStatusObserver->Status();

        }

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Status - return 0x%x" ), state );    

    return state;

    }

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

// CHWRMFmTxImpl::EnableL

// Handles client request to switch FM Tx ON

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

//

void CHWRMFmTxImpl::EnableL(TInt aFrequency)

    {

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::EnableL(%d)"), aFrequency );

    // Defaults to last used frequency

    if ( !aFrequency )

        {

        aFrequency = iFrequencyObserver->Frequency();

        COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::EnableL default freq = %d"), aFrequency );

        }

    // Range check on aFrequency

    if ( !FrequencyRangeCheck(aFrequency) )

        {

        COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::EnableL Out of range error") );

        User::Leave(KErrArgument);

        }

	// round up to the closest frequency

    aFrequency = RoundFreqToNearestStep(aFrequency);

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxOn, TIpcArgs(aFrequency)));

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::EnableL - return" ) );

    }

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

// CHWRMFmTxImpl::DisableL

// Handles client request to switch FM Tx OFF

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

//

void CHWRMFmTxImpl::DisableL()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::DisableL" ) );

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxOff, TIpcArgs()));

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::DisableL - return" ) );

    }

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

// CHWRMFmTxImpl::Frequency

// Returns current Tx frequency

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

//

TInt CHWRMFmTxImpl::Frequency() const

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Frequency" ) );

    TInt frequency = 0;

    if ( iFrequencyObserver )

        {

        frequency = iFrequencyObserver->Frequency();

        }

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::Frequency - return %d" ), frequency );

    return frequency;

    }

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

// CHWRMFmTxImpl::GetFrequencyRangeL

// Handles client query of FM Tx frequency range, and channel spacing (step size)

// This may already be cached, otherwise it's queried from the server-side

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

//

void CHWRMFmTxImpl::GetFrequencyRangeL(TFmTxFrequencyRange& aFrequencyRange) const

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetFrequencyRange" ) );

    if ( iFrequencyObserver )

        {

        if ( iFrequencyObserver->FrequencyRangeUpdated() )

            {

            // Return frequency range from CenRep

            aFrequencyRange.iMinFrequency = iFrequencyObserver->MinFrequency();

            aFrequencyRange.iMaxFrequency = iFrequencyObserver->MaxFrequency();

            aFrequencyRange.iStepSize     = iFrequencyObserver->StepSize();             

            }

        else

            {

            // Request frequency range update from server 

            TPckg<TFmTxFrequencyRange> freqRangePckg(aFrequencyRange);

            User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxGetFreqRange, TIpcArgs(&freqRangePckg)));

            }

        }

    COMPONENT_TRACE4( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetFrequencyRange - return %d-%d, %d" ), aFrequencyRange.iMinFrequency, aFrequencyRange.iMaxFrequency, aFrequencyRange.iStepSize );

    }

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

// CHWRMFmTxImpl::SetFrequencyL

// Handles client request to set the Tx frequency

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

//

void CHWRMFmTxImpl::SetFrequencyL(TInt aFrequency)

    {

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetFrequencyL(%d)"), aFrequency );

    // Range check on aFrequency

    if ( !FrequencyRangeCheck(aFrequency) )

        {

        COMPONENT_TRACE1( ( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetFrequencyL Out of range error") ) );

        User::Leave(KErrArgument);

        }       

    // round up to the closest frequency

	aFrequency = RoundFreqToNearestStep(aFrequency);

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxSetFreq, TIpcArgs(aFrequency)));

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetFrequencyL - return" ) );     

    }

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

// CHWRMFmTxImpl::GetNextClearFrequency

// Handles client request, to scan for available clear frequencies

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

//

void CHWRMFmTxImpl::GetNextClearFrequencyL(TInt& aClearFrequency)

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequencyL") );

    // Call server 

    TPckg<TInt> clearFreqPckg(aClearFrequency);    

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxGetNextClearFreq, TIpcArgs(&clearFreqPckg)));

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequency - return %d" ), aClearFrequency );   

    }

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

// CHWRMFmTxImpl::GetNextClearFrequency

// Handles client request, to scan for available clear frequencies

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

//

void CHWRMFmTxImpl::GetNextClearFrequencyL(TClearFrequencyArray& aClearFrequencyArray, TUint& aCount)

    {

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequencyL, aCount %d"), aCount );

    // Range check on aCount

    if ( aCount == 0 ||

         aCount > KClearFrequencyArrayMax )

        {

        COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequencyL Out of range error") );

        User::Leave(KErrArgument);

        }

    // Call server     

    TPckg<TClearFrequencyArray> clearFreqArrayPckg(aClearFrequencyArray);    

    TPckg<TUint> countPckg(aCount);

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxGetNextClearFreqArray, TIpcArgs(&clearFreqArrayPckg, &countPckg)));

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequency - return" ) );   

    }

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

// CHWRMFmTxImpl::GetNextClearFrequency

// Handles client request, to scan for available clear frequencies

// Asynchronous version

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

//

void CHWRMFmTxImpl::GetNextClearFrequency(TRequestStatus& aStatus, TInt& aClearFrequency)

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequency async") );

    // Call server

    iClearFrequencyPckg.Set( TPckg<TInt>(aClearFrequency) );

    iClient.ExecuteAsyncOperation(EHWRMFmTxGetNextClearFreq, TIpcArgs(&iClearFrequencyPckg), aStatus);

    COMPONENT_TRACE3( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequency - return %d, %d" ), aStatus.Int(), aClearFrequency );

    }

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

// CHWRMFmTxImpl::GetNextClearFrequencyL

// Handles client request, to scan for available clear frequencies

// Asynchronous version

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

//

void CHWRMFmTxImpl::GetNextClearFrequencyL(TRequestStatus& aStatus, TClearFrequencyArray& aClearFrequencyArray, TUint& aCount)

    {

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequencyL async, aCount %d"), aCount );

    // Range check on aCount

    if ( aCount == 0 ||

         aCount > KClearFrequencyArrayMax )

        {

        COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequency Out of range error") );

        User::Leave(KErrArgument);

        }

    // Call server

	iClearFrequencyPckg.Set( TPckg<TClearFrequencyArray>(aClearFrequencyArray) );

	iClearFrequencyCountPckg.Set( TPckg<TUint>(aCount) );

    iClient.ExecuteAsyncOperation(EHWRMFmTxGetNextClearFreqArray, TIpcArgs(&iClearFrequencyPckg, &iClearFrequencyCountPckg), aStatus);

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::GetNextClearFrequency - return" ) );     

    }

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

// CHWRMFmTxImpl::CancelGetNextClearFrequency

// Cancels previous GetNextClearFrequency request

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

//

void CHWRMFmTxImpl::CancelGetNextClearFrequency()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::CancelGetNextClearFrequency" ) );

    TInt error = iClient.ExecuteOperation(EHWRMFmTxCancelGetNextClearFreq, TIpcArgs());

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::CancelGetNextClearFrequency - return %d" ), error );

    }

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

// CHWRMFmTxImpl::SetNextClearFrequency

// Handles client request, to set the Tx frequency to a new available channel

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

//

void CHWRMFmTxImpl::SetNextClearFrequencyL(TInt& aClearFrequency)

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetNextClearFrequencyL") );

    // Call server 

    TPckg<TInt> clearFreqPckg(aClearFrequency);     

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxSetNextClearFreq, TIpcArgs(&clearFreqPckg)));

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetNextClearFrequencyL - return %d" ), aClearFrequency );

    }

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

// CHWRMFmTxImpl::SetNextClearFrequency

// Handles client request, to set the Tx frequency to a new available channel

// Asynchronous version

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

//

void CHWRMFmTxImpl::SetNextClearFrequency(TRequestStatus& aStatus, TInt& aClearFrequency)

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetNextClearFrequency async") );

    // Call server     

    iClearFrequencyPckg.Set( TPckg<TInt>(aClearFrequency) );

    iClient.ExecuteAsyncOperation(EHWRMFmTxSetNextClearFreq, TIpcArgs(&iClearFrequencyPckg), aStatus);

    COMPONENT_TRACE3( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::SetNextClearFrequency - return %d, %d" ), aStatus.Int(), aClearFrequency );

    }

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

// CHWRMFmTxImpl::CancelSetNextClearFrequency

// Cancels previous SetNextClearFrequency request

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

//

void CHWRMFmTxImpl::CancelSetNextClearFrequency()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::CancelSetNextClearFrequency" ) );

    TInt error = iClient.ExecuteOperation(EHWRMFmTxCancelSetNextClearFreq, TIpcArgs());

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::CancelSetNextClearFrequency - return &d" ), error );

    }

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

// CHWRMFmTxImpl::IsAutoFrequencyEnabled

// Returns whether the automatic frequency mode is ON

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

//

TBool CHWRMFmTxImpl::IsAutoFrequencyEnabled()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::IsAutoFrequencyEnabled" ) );

    // Not supported yet

    TBool autoFreqOn = EFalse;

    COMPONENT_TRACE2( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::IsAutoFrequencyEnabled - return %d" ), autoFreqOn );

    return autoFreqOn;

    }

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

// CHWRMFmTxImpl::EnableAutoFrequency

// Handles client request to turn automatic frequency mode ON

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

//

void CHWRMFmTxImpl::EnableAutoFrequencyL()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::EnableAutoFrequencyL") );

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxAutoFreqOn, TIpcArgs()));

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::EnableAutoFrequencyL - return" ) );      

    }

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

// CHWRMFmTxImpl::DisableAutoFrequency

// Handles client request to turn automatic frequency mode OFF

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

//

void  CHWRMFmTxImpl::DisableAutoFrequencyL()

    {

    COMPONENT_TRACE1( _L( "HWRM FM Tx Client - CHWRMFmTxImpl::DisableAutoFrequencyL") );

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMFmTxAutoFreqOff, TIpcArgs()));