/*

* Copyright (c) 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:

*

*/

// System includes

#include <audiooutput.h>

#include <eikdef.h>

#include <coemain.h>

#include <badesca.h>

#include <tzlocalizer.h>

// User includes

#include "cradioenginelogger.h"

#include "radiointernalpskeys.h"

#include "radiointernalcrkeys.h"

#include "cradioaudiorouter.h"

#include "cradiopubsub.h"

#include "cradioengineimp.h"

#include "mradioengineobserver.h"

#include "mradioscanobserver.h"

#include "cradioregion.h"

#include "cradiosettings.h"

#include "mradioenginesettings.h"

#include "mradiosettingssetter.h"

#include "cradiorepositorymanager.h"

#include "cradiordsreceiver.h"

#include "cradiosystemeventcollector.h"

#include "cradionetworkinfolistener.h"

#include "radioengine.hrh"

#include "../../group/buildflags.hrh"

#ifdef __FEATURE_RDS_SIMULATOR

#   include "t_cradiordsreceiversimulator.h"

#endif

// Constants

/** The limit of volume steps that must not be divided */

const TInt KRadioVolumeStepsDividinglimit = 20;

/** If CMMTunerUtility has 200 volume steps, AknVolume control has 20 steps */

const TInt KRadioVolumeStepsDivider = 500;

/** amount of volume steps used previously */

#if defined __WINS__

const TInt KRadioVolumeStepsOld = 10;

#endif // defined __WINS__

/** KRadioRadioSwitchDelay value must not be too small, otherwise problems with

 radioserver will occur, when swithing between valid and invalid presets */

const TInt KRadioRadioSwitchDelay = 300; // In milliseconds

const TInt KRadioThousand = 1000;

const TInt KRadioMillion = KRadioThousand * KRadioThousand;

// Country order from timezones.rss. Default = 0, Japan = 1, America = 2.

const TUint KCityGroupRegions[] =

    {0,0,0,0,0,0,2,0,0,0,0,2,0,2,0,2,0,2,0,2,2,0,2,0,0,2,2,2,0,2,0,0, //32

     0,0,0,0,0,0,0,2,2,0,0,0,0,0,0,0,0,0,0,2,1,0,0,0,0,0,0,0,0,0,0,0, //64

     0,0,0,0,0,2,0,0,0,2,0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //96

     0,0,0,2,0,0,0,0,2,2,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //128

     0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //160

     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,2,2,0,0,0,0,0,0,0,0,0,0, //192

     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0, //224

     2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

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

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

//

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

//

CRadioEngineImp::CRadioEngineImp( CRadioAudioRouter* aAudioRouter )

    : CRadioEngine( aAudioRouter )

    , iAntennaAttached( ETrue )

    , iFreqEventReason( RadioEngine::ERadioFrequencyEventReasonUnknown )

    {

    }

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

//

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

//

void CRadioEngineImp::ConstructL()

    {

    LOG_METHOD_AUTO;

    if ( !iAudioRouter || !iSystemEventCollector || !iSettings )

        {

        User::Leave( KErrNotReady );

        }

    iSystemEventCollector->AddObserverL( this );

    // Initial default values to be over by init

    User::LeaveIfError( iSettings->RadioSetter().SetPowerOn( EFalse ) );

    // The output source needs to be in headset when starting the radio.

    // But if the headset is not connected, audio cannot be heard if it is routed

    // to headset

    RadioEngine::TRadioAudioRoute route = iSystemEventCollector->IsHeadsetConnectedL() ?

                                RadioEngine::ERadioHeadset : RadioEngine::ERadioSpeaker;

    User::LeaveIfError( iSettings->RadioSetter().SetAudioRoute( route ) );

#ifdef __FEATURE_RDS_SIMULATOR

    iRdsReceiver = CRadioRdsReceiverSimulator::NewL( iSettings->EngineSettings() );

#else

    iRdsReceiver = CRadioRdsReceiver::NewL( iSettings->EngineSettings() );

#endif

    iNetworkInfoListener = CRadioNetworkInfoListener::NewL( iSettings->RadioSetter(), NULL );

    iRdsReceiver->AddObserverL( this );

    // Create timer that is used when polling for radio restart.

    iRadioTimer = CPeriodic::NewL( CActive::EPriorityHigh );

    }

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

//

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

//

CRadioEngineImp::~CRadioEngineImp()

    {

    LOG( "CRadioEngineImp::~CRadioEngineImp -- Start" );

    delete iNetworkInfoListener;

    PowerOff();

    delete iRadioTimer;

    DeleteAudioOutput();

    if ( iTunerUtility )

        {

        iTunerUtility->Close();

        }

    if ( iPlayerUtility )

        {

        iPlayerUtility->Close();

        }

    if ( iRdsReceiver )

        {

        iRdsReceiver->RemoveObserver( this );

        }

    delete iRdsReceiver;

    delete iRadioUtility;

    iObservers.Close();

    if ( iSystemEventCollector )

        {

        iSystemEventCollector->RemoveObserver( this );

        }

    delete iSystemEventCollector;

    delete iPubSub;

    if ( iSettings )

        {

        iSettings->RadioSetter().SetObserver( NULL );

        }

    delete iSettings;

    LOG( "CRadioEngineImp::~CRadioEngineImp -- End" );

    }

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

//

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

//

void CRadioEngineImp::SetSystemEventCollector( CRadioSystemEventCollector* aCollector )

    {

    iSystemEventCollector = aCollector;

    }

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

//

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

//

void CRadioEngineImp::SetRadioSettings( CRadioSettings* aSettings )

    {

    iSettings = aSettings;

    iSettings->RadioSetter().SetObserver( this );

    }

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

//

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

//

void CRadioEngineImp::SetRadioPubSub( CRadioPubSub* aPubSub )

    {

    iPubSub = aPubSub;

    }

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

//

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

//

CRadioAudioRouter& CRadioEngineImp::AudioRouter() const

    {

    return *iAudioRouter;

    }

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

//

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

//

CRadioSystemEventCollector& CRadioEngineImp::SystemEventCollector() const

    {

    return *iSystemEventCollector;

    }

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

//

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

//

CRadioSettings& CRadioEngineImp::Settings() const

    {

    return *iSettings;

    }

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

//

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

//

CRadioPubSub* CRadioEngineImp::PubSub() const

    {

    return iPubSub;

    }

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

// Determines radio region

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

//

TRadioRegion CRadioEngineImp::DetermineRegion()

    {

    TRadioRegion region = ERadioRegionNone;

    MRadioEngineSettings& engineSettings = iSettings->EngineSettings();

    if ( iSystemEventCollector->IsMobileNetworkCoverage() )

        {

        region = RegionFromMobileNetwork();

        }

    else

        {

        region = RegionFromTimezone();

        }

    if ( !iSettings->IsRegionAllowed( region ) )

        {

        region = ERadioRegionNone;

        }

    // Region not found, try to use the previously set region

    if ( region == ERadioRegionNone && engineSettings.RegionId() != ERadioRegionNone )

        {

        region = engineSettings.RegionId();

        }

    // All regions have been searched and no direct match found, use default one

    if ( region == ERadioRegionNone )

        {

        region = engineSettings.DefaultRegion();

        }

    return region;

    }

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

// Initializes / reinitializes the radio. If this is not called

// the radio is not functional

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

//

void CRadioEngineImp::InitRadioL( TInt aRegionId, CRadioPubSub* aPubSub )

    {

    LOG_METHOD_AUTO;

    LOG_FORMAT( "CRadioEngineImp::InitRadioL: Region: %d", aRegionId );

    iRadioInitializationState = ERadioNotInitialized;

    iPubSub = aPubSub;

    iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonUnknown;

    if ( iSettings->EngineSettings().RegionId() != aRegionId )

        {

        // Change only when necessary as it changes also the default tuned frequency

        User::LeaveIfError( iSettings->RadioSetter().SetRegionId( aRegionId ) );

        }

    if ( !iRadioUtility )

        {

        iRadioUtility = CRadioUtility::NewL( ETrue );

        }

    if ( !iPlayerUtility )

        {

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

        SetAudioOutput( CAudioOutput::NewL( *iPlayerUtility ) );

        }

    if ( !iTunerUtility )

        {

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

        }

    // Utilities have been created now

    iRadioInitializationState = ERadioUtilitiesConstructed;

    // Before first RequestTunerControl() call it is ok to enable offline mode without checking capabilities

    iTunerUtility->EnableTunerInOfflineMode( ETrue );

    iTunerUtility->RequestTunerControl();

    }

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

//

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

//

TBool CRadioEngineImp::RadioInitialized() const

    {

    return iRadioInitializationState == ERadioTunerControlGranted;

    }

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

// Sets the state for radio audio

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

//

void CRadioEngineImp::EnableAudio( TBool aEnable, TBool aDelay )

    {

    LOG_FORMAT( "CRadioEngineImp::EnableAudio( %d )", aEnable );

    iRadioEnabled = aEnable;

    if ( aDelay )

        {

        SwitchPower( iRadioEnabled );

        }

    else if ( aEnable )

        {

        if ( !RadioInitialized() &&

             iRadioInitializationState == ERadioUtilitiesConstructed &&

             iRadioEnabled &&

             OkToPlay( iSettings->EngineSettings().TunedFrequency() ) )

            {

            iTunerUtility->RequestTunerControl();

            }

        else

            {

            PowerOn();

            }

        }

    else

        {

        PowerOff();

        }

    }

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

// Gets the state for radio audio.

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

//

TBool CRadioEngineImp::RadioAudioEnabled() const

    {

    return iRadioEnabled;

    }

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

// Sets the state for audio overriding

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

//

void CRadioEngineImp::SetAudioOverride( TBool aOverride )

    {

    LOG_FORMAT( "CRadioEngineImp::SetAudioOverride( %d )", aOverride );

    iOverrideAudioResources = aOverride;

    }

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

// Adds an observer for the radio state changes notifications.

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

//

void CRadioEngineImp::AddObserverL( MRadioEngineObserver* aObserver )

    {

    LOG( "CRadioEngineImp::AddObserver" );

    TInt index = iObservers.FindInAddressOrder( aObserver );

    if ( index == KErrNotFound )

        {

        iObservers.InsertInAddressOrderL( aObserver );

        }

    }

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

// Removes an observer from the list of obsevers

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

//

void CRadioEngineImp::RemoveObserver( MRadioEngineObserver* aObserver )

    {

    LOG( "CRadioEngineImp::RemoveObserver" );

    TInt index = iObservers.FindInAddressOrder( aObserver );

    if ( index >= 0 )

        {

        iObservers.Remove( index );

        }

    }

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

//

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

//

TFmRadioFrequencyRange CRadioEngineImp::TunerFrequencyRangeForRegionId( TInt aRegionId ) const

    {

    TFmRadioFrequencyRange result = EFmRangeEuroAmerica;

    switch ( aRegionId )

        {

        case ERadioRegionDefault:

            {

            result = EFmRangeEuroAmerica;

            break;

            }

        case ERadioRegionJapan:

            {

            result = EFmRangeJapan;

            break;

            }

        case ERadioRegionAmerica:

            {

            result = EFmRangeEuroAmerica;

            break;

            }

        default:

            break;

        }

    return result;

    }

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

// Sets radio mode ERadioStereo or ERadioMono

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

void CRadioEngineImp::SetAudioMode( TInt aAudioMode )

    {

    LOG_FORMAT( "CRadioEngineImp::SetAudioMode: aAudioMode: %d", aAudioMode );

    TInt err = KErrNone;

    if ( !RadioInitialized() )

        {

        TInt err = iSettings->RadioSetter().SetOutputMode( aAudioMode );

        NotifyRadioEvent( ERadioEventAudioMode, err );

        }

    else

        {

        err = iTunerUtility->ForceMonoReception( aAudioMode == RadioEngine::ERadioMono );

        if ( err )

            {

            NotifyRadioEvent( ERadioEventAudioMode, err );

            }

        }

    }

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

// Switches power on/off after a delay

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

//

void CRadioEngineImp::SwitchPower( TBool aPowerOn )

    {

    LOG_FORMAT( "CRadioEngineImp::SwitchPower( %d )", aPowerOn );

    if ( RadioInitialized() )

        {

        if ( !aPowerOn || OkToPlay( iSettings->EngineSettings().TunedFrequency() ) )

            {

            iRadioTimer->Cancel();

            if ( aPowerOn )

                {

                iRadioTimer->Start( TTimeIntervalMicroSeconds32( KRadioRadioSwitchDelay * KRadioThousand ),

                        TTimeIntervalMicroSeconds32( 0 ),

                        TCallBack( StaticPowerOnCallback, this ) );

                }

            else

                {

                iRadioTimer->Start( TTimeIntervalMicroSeconds32( KRadioRadioSwitchDelay * KRadioThousand ),

                        TTimeIntervalMicroSeconds32( 0 ),

                        TCallBack( StaticPowerOffCallback, this ) );

                }

            }

        }

    else if ( aPowerOn &&

            iRadioInitializationState == ERadioUtilitiesConstructed &&

            iRadioEnabled &&

            OkToPlay( iSettings->EngineSettings().TunedFrequency() ) )

        {

        iTunerUtility->RequestTunerControl();

        }

    else

        {

        LOG( "CRadioEngineImp::SwitchPower - Unhandled case" );

        LOG_FORMAT( "PowerOn: %d, InitializationState: %d, Enabled: %d, Frequency: %d",

                aPowerOn, iRadioInitializationState, iRadioEnabled, iSettings->EngineSettings().TunedFrequency() );

        }

    }

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

// Executes the power switch

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

//

TInt CRadioEngineImp::StaticPowerOnCallback( TAny* aSelfPtr )

    {

    LOG( "CRadioEngineImp::StaticPowerOnCallback" );

    CRadioEngineImp* self = reinterpret_cast<CRadioEngineImp*>( aSelfPtr );

    if ( self )

        {

        self->iRadioTimer->Cancel(); // prevents the further calls.