/*
* 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 "mradiordsreceiver.h"
#include "radioenginehandler.h"
#include "mradioenginehandlerobserver.h"
#include "radio_global.h"
#include "radiologger.h"
#include "radioenummapper.h"

/*!
 * 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( Seek::Down,              RadioEngine::ERadioDown ),
    ENUM_MAP_ITEM( Seek::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( Seek::NotSeeking,        RadioEngine::ERadioNotSeeking ),
    ENUM_MAP_ITEM( Seek::SeekingUp,         RadioEngine::ERadioSeekingUp ),
    ENUM_MAP_ITEM( Seek::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( Seek::State, ui_enum, KSeekingStateMap )

/*!
 *
 */
RadioEngineHandler::RadioEngineHandler( MRadioEngineHandlerObserver& observer )
    : mObserver( observer )
{
}

/*!
 *
 */
RadioEngineHandler::~RadioEngineHandler()
{
}

/*!
 * Attempts to construct the radio engine
 */
bool RadioEngineHandler::constructEngine()
{
    LOG_METHOD;

    CRadioEngine* engine = NULL;
    TRAPD( err, engine = CRadioEngine::NewL( *this ) );
    if ( err ) {
        return false;
    }

    mEngine.reset( engine );
    TRAP( err,
        mEngine->SystemEventCollector().AddObserverL( &mObserver );
        mEngine->AddObserverL( &mObserver );
    );
    if ( err ) {
        return false;
    }

    mRegion = MAP_TO_UI_REGION( mEngine->Settings().EngineSettings().RegionId() );
    return true;
}

/*!
 * Sets the rds data observer
 */
void RadioEngineHandler::setRdsObserver( MRadioRdsDataObserver* observer )
{
    TRAP_IGNORE( mEngine->RdsReceiver().AddObserverL( observer ) );
}

/*!
 * Starts or stops receiving RDS data
 */
void RadioEngineHandler::setRdsEnabled( bool rdsEnabled )
{
    if ( rdsEnabled ) {
        mEngine->RdsReceiver().StartReceiver();
    } else {
        mEngine->RdsReceiver().StopReceiver();
    }
}

/*!
 * Returns the radio status.
 */
bool RadioEngineHandler::isRadioOn()
{
    return mEngine->Settings().EngineSettings().IsPowerOn();
}

/*!
 * Sets the manual seek status
 */
void RadioEngineHandler::setManualSeekMode( bool manualSeek )
{
    mEngine->SetManualSeekMode( manualSeek );
}

/*!
 * Returns the manual seek status
 */
bool RadioEngineHandler::isInManualSeekMode() const
{
    return mEngine->IsInManualSeekMode();
}

/*!
 * Tune to the specified frequency
 */
void RadioEngineHandler::setFrequency( uint frequency )
{
    mEngine->SetFrequency( frequency );
}

/*!
 * Sets the audio mute state
 */
void RadioEngineHandler::setMute( const bool muted, const bool updateSettings )
{
    mEngine->SetVolumeMuted( muted, updateSettings );
}

/*!
 * Gets the audio mute state
 */
bool RadioEngineHandler::isMuted() const
{
    return mEngine->Settings().EngineSettings().IsVolMuted();
}

/*!
 * Sets the volume level of the FM radio
 */
void RadioEngineHandler::setVolume( int newVolume )
{
    if ( volume() != newVolume ) {
        if ( newVolume > 0 ) {
            mEngine->SetVolumeMuted( EFalse );
        }

        mEngine->SetVolume( newVolume );
    }
}

/*!
 * Gets the volumelevel.
 */
int RadioEngineHandler::volume() const
{
    return mEngine->Settings().EngineSettings().Volume();
}

/*!
 * Gets the max volumelevel.
 */
int RadioEngineHandler::maxVolume() const
{
    return mEngine->MaxVolumeLevel();
}

/*!
 * Increases the volume by one increment
 */
void RadioEngineHandler::increaseVolume()
{
    mEngine->AdjustVolume( RadioEngine::ERadioIncVolume );
}

/*!
 * Decreases the volume by one increment
 */
void RadioEngineHandler::decreaseVolume()
{
    mEngine->AdjustVolume( RadioEngine::ERadioDecVolume );
}


/*!
 * Checks if the antenna is attached
 */
bool RadioEngineHandler::isAntennaAttached() const
{
    return mEngine->IsAntennaAttached();
}

/*!
 * Retrieves the current frequency.
 */
uint RadioEngineHandler::currentFrequency() const
{
    return mEngine->Settings().EngineSettings().TunedFrequency();
}

/*!
 * Returns the minimum allowed frequency in the current region
 */
uint RadioEngineHandler::minFrequency() const
{
    return mEngine->Settings().EngineSettings().MinFrequency();
}

/*!
 * Returns the maximum allowed frequency in the current region
 */
uint RadioEngineHandler::maxFrequency() const
{
    return mEngine->Settings().EngineSettings().MaxFrequency();
}

/*!
 * Checks if the given frequency is valid in the current region
 */
bool RadioEngineHandler::isFrequencyValid( uint frequency ) const
{
    return mEngine->IsFrequencyValid( frequency );
}

/*!
 * Scan up to the next available frequency
 */
void RadioEngineHandler::seek( Seek::Direction direction )
{
    LOG_TIMESTAMP( "Seek" );
    mEngine->Seek( MAP_FROM_UI_DIRECTION( direction ) );
}

/*!
 * Cancel previously requested scan, and return to the already tuned frequency
 */
void RadioEngineHandler::cancelSeek()
{
    mEngine->CancelSeek();
}

/*!
 * Returns the engine seeking state
 */
Seek::State RadioEngineHandler::seekingState() const
{
    return MAP_TO_UI_SEEKING_STATE( mEngine->Seeking() );
}

/*!
 * return step size for tuning.
 */
uint RadioEngineHandler::frequencyStepSize() const
{
    return mEngine->Settings().EngineSettings().FrequencyStepSize();
}

/*!
 * Returns the selected radio region
 */
RadioRegion::Region RadioEngineHandler::region() const
{
    return mRegion;
}

/*!
 * Sets whether or not audio should be routed to loudspeaker
 */
void RadioEngineHandler::setAudioRouteToLoudspeaker( bool loudspeaker )
{
    TRAPD( err, mEngine->AudioRouter().SetAudioRouteL( loudspeaker ? RadioEngine::ERadioSpeaker
                                                       : RadioEngine::ERadioHeadset ) );
    if ( err ) {
        LOG_FORMAT( "Failed to set audioroute: UseLoudspeadker: %d", loudspeaker );
    }
}

/*!
 * Checks if audio is routed to loudspeaker
 */
bool RadioEngineHandler::isAudioRoutedToLoudspeaker() const
{
    return mEngine->Settings().EngineSettings().AudioRoute() == RadioEngine::ERadioSpeaker;
}

/*!
 * Returns the repository manager.
 */
MRadioApplicationSettings& RadioEngineHandler::applicationSettings() const
{
    return mEngine->Settings().ApplicationSettings();
}

/*!
 * \reimp
 */
CRadioAudioRouter* RadioEngineHandler::InitAudioRouterL()
{
    return CRadioAudioRouter::NewL( mObserver );
}

/*!
 * \reimp
 */
CRadioSystemEventCollector* RadioEngineHandler::InitSystemEventCollectorL()
{
    return CRadioSystemEventCollector::NewL();
}

/*!
 * \reimp
 */
CRadioSettings* RadioEngineHandler::InitSettingsL()
{
    return CRadioSettings::NewL();
}