/*
* 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:
*
*/

// User includes
#include "cradioengine.h"
#include "cradioaudiorouter.h"
#include "cradiosystemeventcollector.h"
#include "cradiosettings.h"
#include "mradioenginesettings.h"
#include "cradiopubsub.h"
#include "cradiorepositorymanager.h"
#include "mradiordsreceiver.h"
#include "cradioenginehandler.h"
#include "mradioenginehandlerobserver.h"
#include "radio_global.h"
#include "radiologger.h"
#include "radioenummapper.h"

/**
 * Delayed tuning delay
 */
const TInt KTuneDelay = 100000;

/*!
 * Map to translate seek direction enum from its definition in the engine to
 * its definition in the ui and vice versa
 */
BEGIN_ENUM_MAP( KSeekDirectionMap )
    ENUM_MAP_ITEM( Seeking::Down, RadioEngine::ERadioDown ),
    ENUM_MAP_ITEM( Seeking::Up,   RadioEngine::ERadioUp )
END_ENUM_MAP( KSeekDirectionMap )

/*!
 * Convenience macro to do the mapping of seek directions
 */
#define MAP_FROM_UI_DIRECTION(ui_enum) MAP_FROM_UI_ENUM( RadioEngine::TRadioTuneDirection, ui_enum, KSeekDirectionMap )

/*!
 * Map to translate radio region enum from its definition in the engine to
 * its definition in the ui and vice versa
 */
BEGIN_ENUM_MAP( KRegionMap )
    ENUM_MAP_ITEM( RadioRegion::None,       ERadioRegionNone ),
    ENUM_MAP_ITEM( RadioRegion::Default,    ERadioRegionDefault ),
    ENUM_MAP_ITEM( RadioRegion::Japan,      ERadioRegionJapan ),
    ENUM_MAP_ITEM( RadioRegion::America,    ERadioRegionAmerica ),
    ENUM_MAP_ITEM( RadioRegion::Poland,     ERadioRegionPoland ),
END_ENUM_MAP( KRegionMap )

/*!
 * Convenience macros to do the mapping of radio regions
 */
#define MAP_FROM_UI_REGION(ui_enum) MAP_FROM_UI_ENUM( TRadioRegion, ui_enum, KRegionMap )
#define MAP_TO_UI_REGION(engine_enum) MAP_TO_UI_ENUM( RadioRegion::Region, engine_enum, KRegionMap )

/*!
 * Map to translate seeking state enum from its definition in the engine to
 * its definition in the ui and vice versa
 */
BEGIN_ENUM_MAP( KSeekingStateMap )
    ENUM_MAP_ITEM( Seeking::NotSeeking,     RadioEngine::ERadioNotSeeking ),
    ENUM_MAP_ITEM( Seeking::SeekingUp,      RadioEngine::ERadioSeekingUp ),
    ENUM_MAP_ITEM( Seeking::SeekingDown,    RadioEngine::ERadioSeekingDown )
END_ENUM_MAP( KSeekingStateMap )

/*!
 * Convenience macro to do the mapping of seeking states
 */
#define MAP_TO_UI_SEEKING_STATE(ui_enum) MAP_TO_UI_ENUM( Seeking::State, ui_enum, KSeekingStateMap )


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


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CRadioEngineHandler::CRadioEngineHandler( MRadioEngineHandlerObserver& aObserver )
    : iObserver( aObserver )
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CRadioEngineHandler::~CRadioEngineHandler()
    {
    if ( iEngine ) {
        iEngine->Settings().Repository().RemoveObserver( &iObserver );
    }

    delete iEngine;
    delete iDelayTimer;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::ConstructL()
    {
    LOG_METHOD;

    iDelayTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iEngine = CRadioEngine::NewL( *this );

    iEngine->SystemEventCollector().AddObserverL( &iObserver );
    iEngine->Settings().Repository().AddObserverL( &iObserver );
    iEngine->AudioRouter().SetAudioRouteL( RadioEngine::ERadioHeadset );
    iEngine->AddObserverL( &iObserver );

    iRegion = MAP_TO_UI_REGION( iEngine->Settings().EngineSettings().RegionId() );

//    iEngineHolder->PubSub().SetControlEventObserver( &iObserver );

//    iRadioEngine->SetVolumeMuted( EFalse );
//    iRadioEngine->SetVolume( MaxVolume() );

//    CVRRepositoryManager::GetRepositoryValueL( KVRCRUid, KVRCRLaunchCount, usageCount );
//    CVRRepositoryManager::SetRepositoryValueL( KVRCRUid, KVRCRLaunchCount, ++usageCount );
//    iControlEventObserver = CVRControlEventObserverImpl::NewL( *this );
//    doc->PubSubL().SetControlEventObserver( iControlEventObserver );
    }

// ---------------------------------------------------------------------------
// Sets the rds data observer
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::SetRdsObserver( MRadioRdsDataObserver* aObserver )
    {
    TRAP_IGNORE( iEngine->RdsReceiver().AddObserverL( aObserver ) );
    }

// ---------------------------------------------------------------------------
// Returns the radio status.
// ---------------------------------------------------------------------------
//
TBool CRadioEngineHandler::IsRadioOn()
    {
    return iEngine->Settings().EngineSettings().IsPowerOn();
    }

// ---------------------------------------------------------------------------
// Tune to the specified frequency
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::Tune( TUint aFrequency )
    {
    iEngine->SetFrequency( aFrequency );
    }

// ---------------------------------------------------------------------------
// Tune to the specified frequency after a delay
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::TuneWithDelay( TUint aFrequency )
    {
    iFrequency = aFrequency;
    iDelayTimer->Cancel();
    iDelayTimer->Start( KTuneDelay, KTuneDelay, TCallBack( TuneDelayCallback, this ) );
    }

// ---------------------------------------------------------------------------
// Sets the audio mute state
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::SetMuted( const TBool aMuted )
    {
    iEngine->SetVolumeMuted( aMuted );
    }

// ---------------------------------------------------------------------------
// Gets the audio mute state
// ---------------------------------------------------------------------------
//
TBool CRadioEngineHandler::IsMuted() const
    {
    return iEngine->Settings().EngineSettings().IsVolMuted();
    }

// ---------------------------------------------------------------------------
// Sets the volume level of the FM radio
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::SetVolume( TInt aVolume )
    {
    if ( Volume() != aVolume )
        {
        if ( aVolume > 0 )
            {
            iEngine->SetVolumeMuted( EFalse );
            }

        iEngine->SetVolume( aVolume );
        }
    }

// ---------------------------------------------------------------------------
// Gets the volumelevel.
// ---------------------------------------------------------------------------
//
TInt CRadioEngineHandler::Volume() const
    {
    return iEngine->Settings().EngineSettings().Volume();
    }

// ---------------------------------------------------------------------------
// Gets the max volumelevel.
// ---------------------------------------------------------------------------
//
TInt CRadioEngineHandler::MaxVolume() const
    {
    return iEngine->MaxVolumeLevel();
    }

// ---------------------------------------------------------------------------
// Increases the volume by one increment
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::IncreaseVolume()
    {
    iEngine->AdjustVolume( RadioEngine::ERadioIncVolume );
    }

// ---------------------------------------------------------------------------
// Decreases the volume by one increment
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::DecreaseVolume()
    {
    iEngine->AdjustVolume( RadioEngine::ERadioDecVolume );
    }

// ---------------------------------------------------------------------------
// Checks if the antenna is attached
// ---------------------------------------------------------------------------
//
TBool CRadioEngineHandler::IsAntennaAttached() const
    {
    return iEngine->IsAntennaAttached();
    }

// ---------------------------------------------------------------------------
// Retrieves the current frequency.
// ---------------------------------------------------------------------------
//
TUint CRadioEngineHandler::TunedFrequency() const
    {
    return iEngine->Settings().EngineSettings().TunedFrequency();
    }

// ---------------------------------------------------------------------------
// Returns the minimum allowed frequency in the current region
// ---------------------------------------------------------------------------
//
TUint CRadioEngineHandler::MinFrequency() const
    {
    return iEngine->Settings().EngineSettings().MinFrequency();
    }

// ---------------------------------------------------------------------------
// Returns the maximum allowed frequency in the current region
// ---------------------------------------------------------------------------
//
TUint CRadioEngineHandler::MaxFrequency() const
    {
    return iEngine->Settings().EngineSettings().MaxFrequency();
    }

// ---------------------------------------------------------------------------
// Checks if the given frequency is valid in the current region
// ---------------------------------------------------------------------------
//
TBool CRadioEngineHandler::IsFrequencyValid( TUint aFrequency ) const
    {
    return iEngine->IsFrequencyValid( aFrequency );
    }

// ---------------------------------------------------------------------------
// Scan up to the next available frequency
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::Seek( Seeking::Direction direction )
    {
    LOG_TIMESTAMP( "Seek" );
    iEngine->Seek( MAP_FROM_UI_DIRECTION( direction ) );
    }

// ---------------------------------------------------------------------------
// Cancel previously requested scan, and return to the
// already tuned frequency
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::CancelSeek()
    {
    iEngine->CancelSeek();
    }

// ---------------------------------------------------------------------------
// Returns the engine seeking state
// ---------------------------------------------------------------------------
//
Seeking::State CRadioEngineHandler::SeekingState() const
    {
    return MAP_TO_UI_SEEKING_STATE( iEngine->Seeking() );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::StartScan( MRadioScanObserver& aObserver )
    {
    iEngine->StartScan( aObserver );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::StopScan( TInt aError )
    {
    iEngine->StopScan( aError );
    }

// ---------------------------------------------------------------------------
// return step size for tuning.
// ---------------------------------------------------------------------------
//
TUint32 CRadioEngineHandler::FrequencyStepSize() const
    {
    return iEngine->Settings().EngineSettings().FrequencyStepSize();
    }

// ----------------------------------------------------------------------------------------------------
// Returns the selected radio region
// ----------------------------------------------------------------------------------------------------
//
RadioRegion::Region CRadioEngineHandler::Region() const
    {
    return iRegion;
    }

// ---------------------------------------------------------------------------
// Sets whether or not audio should be routed to loudspeaker
// ---------------------------------------------------------------------------
//
void CRadioEngineHandler::SetAudioRouteToLoudspeaker( TBool aLoudspeaker )
    {
    TRAPD( err, iEngine->AudioRouter().SetAudioRouteL( aLoudspeaker ? RadioEngine::ERadioSpeaker
                                                         : RadioEngine::ERadioHeadset ) );
    if ( err )
        {
        LOG_FORMAT( "Failed to set audioroute: UseLoudspeadker: %d", aLoudspeaker );
        }
    }

// ---------------------------------------------------------------------------
// Checks if audio is routed to loudspeaker
// ---------------------------------------------------------------------------
//
TBool CRadioEngineHandler::IsAudioRoutedToLoudspeaker() const
    {
    return iEngine->Settings().EngineSettings().AudioRoute() == RadioEngine::ERadioSpeaker;
    }

// ---------------------------------------------------------------------------
// Returns ar reference to the publish & subscribe handler
// ---------------------------------------------------------------------------
//
CRadioPubSub& CRadioEngineHandler::PubSub()
    {
    return *iEngine->PubSub();
    }

// ---------------------------------------------------------------------------
// Returns the repository manager.
// ---------------------------------------------------------------------------
//
CRadioRepositoryManager& CRadioEngineHandler::Repository() const
    {
    return iEngine->Settings().Repository();
    }

// ---------------------------------------------------------------------------
// Returns the repository manager.
// ---------------------------------------------------------------------------
//
MRadioApplicationSettings& CRadioEngineHandler::ApplicationSettings() const
    {
    return iEngine->Settings().ApplicationSettings();
    }

// ---------------------------------------------------------------------------
// From MRadioEngineInitializer
//
// ---------------------------------------------------------------------------
//
CRadioAudioRouter* CRadioEngineHandler::InitAudioRouterL()
    {
    return CRadioAudioRouter::NewL( iObserver );
    }

// ---------------------------------------------------------------------------
// From MRadioEngineInitializer
//
// ---------------------------------------------------------------------------
//
CRadioSystemEventCollector* CRadioEngineHandler::InitSystemEventCollectorL()
    {
    return CRadioSystemEventCollector::NewL();
    }

// ---------------------------------------------------------------------------
// From MRadioEngineInitializer
//
// ---------------------------------------------------------------------------
//
CRadioSettings* CRadioEngineHandler::InitSettingsL()
    {
    return CRadioSettings::NewL();
    }

// ---------------------------------------------------------------------------
// From MRadioEngineInitializer
//
// ---------------------------------------------------------------------------
//
CRadioPubSub* CRadioEngineHandler::InitPubSubL()
    {
    return CRadioPubSub::NewL();
    }

// --------------------------------------------------------------------------------
// Static callback function to be used by the tune delay timer
// --------------------------------------------------------------------------------
//
TInt CRadioEngineHandler::TuneDelayCallback( TAny* aSelf )
    {
    CRadioEngineHandler* self = static_cast<CRadioEngineHandler*>( aSelf );
    self->iDelayTimer->Cancel();
    self->Tune( self->iFrequency );
    return 0; // Not used by CPeriodic
    }