/*

* 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:  The class implements the core functionality of the Radio Engine

*

*/

//  INCLUDE FILES

#include <AudioOutput.h>

#include <AccMonitor.h>

#include <bautils.h>

#include <coemain.h>

#include <data_caging_path_literals.hrh>

#include "fmradioengine.h"

#include "fmradioenginestatechangecallback.h"

#include "debug.h"

#include "fmradioengineradiosettings.h"

#include "fmradioengineradiostatehandler.h"

#include "fmradioenginecentralrepositoryhandler.h"

#include "fmradioenginecrkeys.h"

#include "fmradiosystemeventdetector.h"

#include "fmradiomobilenetworkinfolistener.h"

#include "fmradiopubsub.h"

#include "fmradiordsreceiver.h"

#include "fmradiordsreceiversimulator.h"

#include "fmradioaccessoryconnection.h"

#ifndef __ACCESSORY_FW

#include "fmradioenginedosserverobserver.h"

#endif

// CONSTANTS

const TInt KFMRadioNumberOfVolumeSteps = 20;

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

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

// CRadioEngine::CRadioEngine

// Default class constructor.

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

//

CRadioEngine::CRadioEngine(

    MRadioEngineStateChangeCallback& aCallback)

    :

    {

    }

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

// CRadioEngine::ConstructL

// Second phase class constructor.

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

//

void CRadioEngine::ConstructL()

    {

    FTRACE(FPrint(_L("CRadioEngine::ConstructL()")));

    InitializeResourceLoadingL(); 

    iRadioSettings = new ( ELeave ) TRadioSettings;

    iCentralRepositoryHandler = CCentralRepositoryHandler::NewL( *iRadioSettings );

#ifdef __WINS__

    // NetworkInfoListener takes care of listening to the network id and country code.

    iNetworkInfoListener = CFMRadioMobileNetworkInfoListener::NewL( *this );

#endif

    // for monitoring network availability

	iSystemEventDetector = CFMRadioSystemEventDetector::NewL( *this );

    // create an instance of Radio Utility factory and indicate

    // FM Radio is a primary client

    iRadioUtility = CRadioUtility::NewL( ETrue );

    // Get a tuner utility

    iFmTunerUtility = &iRadioUtility->RadioFmTunerUtilityL( *this );

    // Get a player utility

    iPlayerUtility = &iRadioUtility->RadioPlayerUtilityL( *this );

    TInt maxVolume = 0;

    iPlayerUtility->GetMaxVolume( maxVolume );

    FTRACE(FPrint(_L("CRadioEngine::ConstructL()  maxVolume %d"), maxVolume ) );

    // calculate multiplier for scaling the UI volume to the value used by DevSound

    iUiVolumeFactor = ( static_cast<TReal> ( maxVolume ) / KFMRadioNumberOfVolumeSteps );

    // Get a preset utility

    iPresetUtility = CRadioFmPresetUtility::NewL( *this );

#ifdef __WINS__

    iRdsReceiver = CFMRadioRdsReceiverSimulator::NewL( *iRadioSettings );

    static_cast<CFMRadioRdsReceiverSimulator*> ( iRdsReceiver )->SetRadioEngineForRadioFmTunerSimulation( this );

#else

    iRdsReceiver = CFMRadioRdsReceiver::NewL( *iRadioSettings );

#endif

    iRdsReceiver->AddObserver( this );

    iStateHandler = CRadioStateHandler::NewL( this );

#ifndef __ACCESSORY_FW

    iDosServerObserver = CDosServerObserver::NewL( this, iRadioSettings );

#else

#ifndef __WINS

    TRAP_IGNORE( iAudioOutput = CAudioOutput::NewL( *iPlayerUtility ) );

#endif

#endif

    iTopFrequency = 0;

    iBottomFrequency = 0;

        {

        iInCall = ETrue;

        }

    // accessory observer

    iHeadsetObserver = CFMRadioAccessoryConnection::NewL();

    iHeadsetObserver->SetObserver( this );    

    // Set audio output to current setting

    if ( iHeadsetObserver->WiredHeadsetConnected() )

        {

        SetAudioOutput( EFMRadioOutputHeadset );

        }

    else

        {

        SetAudioOutput( EFMRadioOutputIHF );

        }

    // Assume headset is connected, we'll be notified later if it's not.

    iRadioSettings->SetHeadsetConnected();

    // Create P&S interface.

    iPubSub = CFMRadioPubSub::NewL();

    // Publish antenna status as connected, we'll be notified later if it's not.

    iPubSub->PublishAntennaStatusL( EFMRadioPSHeadsetConnected );

    iPubSub->PublishFrequencyDecimalCountL( 

            TFMRadioPSFrequencyDecimalCount( iRadioSettings->DecimalCount() ) );

    FTRACE(FPrint(_L("CRadioEngine::ConstructL() End ")));

    }

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

// CRadioEngine::NewL

// Two-phased class constructor.

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

//

EXPORT_C CRadioEngine* CRadioEngine::NewL(

    MRadioEngineStateChangeCallback& aCallback )

    {

    CRadioEngine* self = new (ELeave) CRadioEngine( aCallback );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CRadioEngine::~CRadioEngine

// Destructor of CRadioEngine class.

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

////

EXPORT_C CRadioEngine::~CRadioEngine()

    {

    FTRACE(FPrint(_L("CRadioEngine::~CRadioEngine()")));

    if ( iCentralRepositoryHandler) 

        {

        iCentralRepositoryHandler->SaveEngineSettings();

        delete iCentralRepositoryHandler;

        }

    delete iPubSub;

    delete iHeadsetObserver;

	RadioOff();

	delete iNetworkInfoListener;     

	delete iSystemEventDetector;      

    delete iPresetUtility;

    delete iRadioSettings;

    delete iStateHandler;

    if ( iAudioOutput )

        {

        TRAP_IGNORE(iAudioOutput->SetAudioOutputL(CAudioOutput::EPrivate));

        delete iAudioOutput;

        }

    if ( iRdsReceiver )

        {

        iRdsReceiver->RemoveObserver( this );

        }

    delete iRdsReceiver;

    if ( iFmTunerUtility )

        {

        iFmTunerUtility->Close();

        }

    if ( iPlayerUtility )

        {

        iPlayerUtility->Close();

        }

    delete iRadioUtility;

    #ifndef __ACCESSORY_FW

    if (iDosServerObserver)

        {

        iDosServerObserver->SetAudioRouting(EFMRadioOutputHeadset);

        delete iDosServerObserver;

        }

    #endif

	if ( iFMRadioEngineResourceOffset > 0 )

        {

        CCoeEnv::Static()->DeleteResourceFile( iFMRadioEngineResourceOffset );

        }

    }

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

// CRadioEngine::InitializeRadio

// Set radio settings to their default values.

// Returns: None

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

//

EXPORT_C void CRadioEngine::InitializeRadio()

      {

      FTRACE(FPrint(_L("CRadioEngine::InitializeRadio()")));

      iInitializeRadioRequestExists = ETrue;

      Tune( iRadioSettings->Frequency() );

#ifdef __WINS__

      // MrftoRequestTunerControlComplete never completes in WINS, so initialize RdsReceiver here

      TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility, iPubSub ) );

#endif

      }

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

// CRadioEngine::RadioOn

// Start the radio.

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

//

EXPORT_C void CRadioEngine::RadioOn()

    {

    FTRACE(FPrint(_L("CRadioEngine::RadioOn()")));

    if ( !iRadioSettings->IsRadioOn() )

        {

        FTRACE(FPrint(_L("CRadioEngine::RadioOn() - Turning Radio on, calling play")));

        iRadioSettings->SetRadioOn();

        iPlayerUtility->Play();

        if ( iPubSub )

            {

            TRAP_IGNORE( iPubSub->PublishStateL( ETrue ) );

            }

       }

    }

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

// CRadioEngine::RadioOff

// Stops the radio.

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

//

EXPORT_C void CRadioEngine::RadioOff()

    {

    FTRACE(FPrint(_L("CRadioEngine::RadioOff()")));

    if ( iStateHandler )

        {

        iStateHandler->Cancel();

        }

    iCurrentRadioState = EStateRadioOff;

    if( iFmTunerUtility &&

        iRadioSettings &&

        iRadioSettings->RadioMode() == ERadioTunerMode )

        {

        CancelScan();

        }

    if ( iPlayerUtility &&

         iPlayerUtility->PlayerState() == ERadioPlayerPlaying )

        {

        iPlayerUtility->Stop();

        }

    if ( iPubSub )

        {

        TRAP_IGNORE( iPubSub->PublishStateL( EFalse ) );

        }

    }

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

// CRadioEngine::IsRadioOn

// Returns the radio status.

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

//

EXPORT_C TBool CRadioEngine::IsRadioOn()

	{

	return iRadioSettings->IsRadioOn();

	}

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

// CRadioEngine::IsOfflineProfileL

// Checks if offine profile is current active profile

// Returns: true/false 

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

//

EXPORT_C TBool CRadioEngine::IsOfflineProfileL()

	{

	return iCentralRepositoryHandler->IsOfflineProfileActiveL();

	}

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

// CRadioEngine::Tune

// Tune to the specified frequency

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

//

EXPORT_C void CRadioEngine::Tune( TInt aFrequency, TRadioMode aRadioMode )

    {

    FTRACE(FPrint(_L("CRadioEngine::Tune()")));

    iTempFrequency = aFrequency;

    iRadioSettings->SetRadioMode( aRadioMode );

        {

        iFmTunerUtility->SetFrequency( aFrequency );

        }

    else

        {

        StoreAndPublishFrequency( aFrequency );

        }

    if ( iPubSub )

    	{

        TRAP_IGNORE

            (

            iPubSub->PublishFrequencyL( aFrequency );

            if( aRadioMode == ERadioTunerMode )

                {

                iPubSub->PublishChannelNameL( KNullDesC );

                iPubSub->PublishChannelL( KErrNotFound );

                }

            )

    	}

    }

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

// CRadioEngine::SetTunerModeOn

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

//

EXPORT_C void CRadioEngine::SetTunerModeOn()

    {

    FTRACE(FPrint(_L("CRadioEngine::SetTunerModeOn()")));

    iRadioSettings->SetRadioMode( ERadioTunerMode );

    if ( iPubSub )

        {

        TRAP_IGNORE

            (

            iPubSub->PublishChannelNameL( KNullDesC );

            iPubSub->PublishChannelL( KErrNotFound );

            )

        }

    }

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

// CRadioEngine::ScanUp

// Scan up to the next available frequency

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

//

EXPORT_C void CRadioEngine::ScanUp()

    {

    iRadioSettings->SetRadioMode(ERadioTunerMode);

    iFmTunerUtility->StationSeek( ETrue );

    TRAP_IGNORE

        (

        iTuningState = EFMRadioPSTuningStarted;

        iPubSub->PublishTuningStateL( iTuningState );

        iPubSub->PublishChannelNameL( KNullDesC );

        iPubSub->PublishChannelL( KErrNotFound );

        )

    }

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

// CRadioEngine::ScanDown

// Scan down to the last available frequency

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

//

EXPORT_C void CRadioEngine::ScanDown()

    {

    iRadioSettings->SetRadioMode(ERadioTunerMode);

    iFmTunerUtility->StationSeek( EFalse );

    TRAP_IGNORE

        (

        iTuningState = EFMRadioPSTuningStarted;

        iPubSub->PublishTuningStateL( iTuningState );

        iPubSub->PublishChannelNameL( KNullDesC );

        iPubSub->PublishChannelL( KErrNotFound );

        )

    }

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

// CRadioEngine::CancelScan

// Cancel previously requested scan, and return to the

// already tuned frequency

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

//

EXPORT_C void CRadioEngine::CancelScan()

    {

    if( iFmTunerUtility )

        {

        iFmTunerUtility->CancelStationSeek();

        iTuningState = EFMRadioPSTuningUninitialized;

        TRAP_IGNORE(iPubSub->PublishTuningStateL( iTuningState ));

        }

    }

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

// CRadioEngine::IsHeadsetConnected

// Check whether the headset is currently connected

// Returns: true/false

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

//

EXPORT_C TBool CRadioEngine::IsHeadsetConnected() const

    {

    return iRadioSettings->IsHeadsetConnected();

    }

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

// CRadioEngine::IsFlightmodeEnabled

// Check whether flight mode is currently enabled

// Returns: true/false

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

//

EXPORT_C TBool CRadioEngine::IsFlightModeEnabled() const

    {

    return iRadioSettings->IsFlightModeEnabled();

    }

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

// CRadioEngine::SetMuteOn

// Sets the audio mute state

// Returns: None

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

//

EXPORT_C void CRadioEngine::SetMuteOn(

    TBool aMuteOn)  // a flag indicating if set mute on

    {

    FTRACE(FPrint(_L("CRadioEngine::SetMuteOn()")));

    TInt error = KErrNone;

    if ( IsMuteOn()  && (!aMuteOn) )

        {

        error = iPlayerUtility->Mute( EFalse );

        if( !error )

            {

            FTRACE(FPrint(_L("CRadioEngine::SetMuteOn() setting mute off")));

            iRadioSettings->SetMuteOff();

            TRAP_IGNORE(iPubSub->PublishRadioMuteStateL(EFalse));

            }

        }

    else if ( !IsMuteOn() && aMuteOn )

        {

        error = iPlayerUtility->Mute( ETrue );

        if( !error )

            {

            FTRACE(FPrint(_L("CRadioEngine::SetMuteOn() setting mute on")));

            iRadioSettings->SetMuteOn();

            TRAP_IGNORE(iPubSub->PublishRadioMuteStateL(ETrue));

            }

        }

    iStateHandler->Callback( MRadioEngineStateChangeCallback::EFMRadioEventSetMuteState, error );

    }

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

// CRadioEngine::IsMuteOn

// Gets the audio mute state

// Returns: true/false

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

//

EXPORT_C TBool CRadioEngine::IsMuteOn() const

    {

    return iRadioSettings->IsMuteOn();

    }

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

// CRadioEngine::GetPresetIndex

// Retrieve the currently selected channel

// Returns: the preset channel index

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

//

EXPORT_C TInt CRadioEngine::GetPresetIndex() const

    {

    return iRadioSettings->CurrentPreset();

    }

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

// CRadioEngine::SetPresetFrequency

// Update the channel located at the index to use the frequency specified.

// Returns: None

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