/*

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

*

*/

#include "cmmfradiobackendengine.h"

extern "C" {

#include "xaradioitfadaptation.h"

#include "xaadaptationmmf.h"

#include "xaadptbasectx.h"

}

CMMFRadioBackendEngine *CMMFRadioBackendEngine::s_instance = 0;

CMMFRadioBackendEngine* CMMFRadioBackendEngine::Instance()

{

    if (!s_instance)

    {

        s_instance = new CMMFRadioBackendEngine();

        if (s_instance)

        {

            s_instance->ConstructL();

        }

    }

    return s_instance;

}

void CMMFRadioBackendEngine::DeleteInstance()

{

    if (iFmTunerUtility)

    {

        iFmTunerUtility->Close();

        iFmTunerUtility = NULL;

    }

    if (iRadioPlayerUtility)

    {

        iRadioPlayerUtility->Close();

        iRadioPlayerUtility = NULL;

    }

    if (iRadioUtility)

    {

        delete iRadioUtility;

        iRadioUtility = NULL;

    }

}

CMMFRadioBackendEngine::~CMMFRadioBackendEngine()

{

}

CMMFRadioBackendEngine::CMMFRadioBackendEngine()

{

}

void CMMFRadioBackendEngine::ConstructL()

{

    iRadioUtility = CRadioUtility::NewL( ETrue );

    if (iRadioUtility)

    {

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

    }

    if (iFmTunerUtility)

    {

        iFmTunerUtility->EnableTunerInOfflineMode( ETrue );

        iFmTunerUtility->RequestTunerControl();  

    }

    if (iRadioUtility)

    {

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

    }

    SetForceMonoFlag();

    iDefaultFrequency = RADIO_DEFAULT_FREQ;

    iDefaultFreqRange = (TFmRadioFrequencyRange)RADIO_DEFAULT_FREQ_RANGE;

    iDefaultMinFreq = RADIO_DEFAULT_MIN_FREQ;

    iDefaultMaxFreq = RADIO_DEFAULT_MAX_FREQ;

    iAdaptContext = (XAAdaptationBaseCtx*)CMMFRadioBackendEngine::Instance();

}

void CMMFRadioBackendEngine::StationSeek(TBool aUpwards)

{

    if (iFmTunerUtility)

    {

        iFmTunerUtility->StationSeek(aUpwards);

    }

}

void CMMFRadioBackendEngine::SetFrequency(TInt aFreq)

{

//  DEBUG_CPP_API_A1("CMMFRadioBackendEngine::SetFrequency: %d", aFreq);

    if (iFmTunerUtility)

    {

        iFmTunerUtility->SetFrequency(aFreq);

    }

}

{

//    DEBUG_CPP_API("CMMFRadioBackendEngine::GetFrequency");

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetFrequency(aFreq);

        if (ret != KErrNone)

        {

            aFreq = iDefaultFrequency;

            ret = KErrNone;

        }

    }

//  DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFrequency RET: %d", ret);

}

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetSignalStrength(aSignalStrength);

    }

//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetSignalStrength RET: %d", ret);

}

void CMMFRadioBackendEngine::CancelSetFrequency()

{

    if (iFmTunerUtility)

    {

        iFmTunerUtility->CancelSetFrequency();

    }

}

void CMMFRadioBackendEngine::CancelStationSeek()

{

    if (iFmTunerUtility)

    {

        iFmTunerUtility->CancelStationSeek();

    }

}

void CMMFRadioBackendEngine::SetFreqRange(TFmRadioFrequencyRange aRange)

{

    if (iFmTunerUtility)

    {

        iFmTunerUtility->SetFrequencyRange(aRange);

    }

}

{

    TInt ret = KErrNotFound;

    TInt minFreq;

    TInt maxFreq;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetFrequencyRange((TFmRadioFrequencyRange&)aRange, (TInt&)minFreq, (TInt&)maxFreq);

        if (ret != KErrNone)

        {

            minFreq = iDefaultMinFreq;

            maxFreq = iDefaultMaxFreq;

            aRange = iDefaultFreqRange;

            ret = KErrNone;

        }

    }

}

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetFrequencyRange((TFmRadioFrequencyRange&)aRange, (TInt&)aMinFreq, (TInt&)aMaxFreq);

        if (ret != KErrNone)

        {

            aRange = iDefaultFreqRange;

            aMinFreq = iDefaultMinFreq;

            aMaxFreq = iDefaultMaxFreq;

            ret = KErrNone;

        }

    }

}

{

    TInt ret = KErrNotFound; 

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->SetVolume(aVol);

    }

}

{

    TInt ret = KErrNotFound;

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->Mute(aMute);

    }

}

{

    TInt ret = KErrNotFound;

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->GetVolume(aVol);

    }

}

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetForcedMonoReception(forceMono);

        if (ret == KErrNotReady)

        {

            aForcedMono = XA_STEREOMODE_AUTO; // Radio Utility Default value

        }

    }

    if (forceMono)

    {

        aForcedMono = XA_STEREOMODE_MONO;

    }

    else

    {

        if (iForceStereo)

            aForcedMono = XA_STEREOMODE_STEREO;

        else

            aForcedMono = XA_STEREOMODE_AUTO;

    }

}

void CMMFRadioBackendEngine::PlayRadio()

{

    if (iRadioPlayerUtility)

    {

        iRadioPlayerUtility->Play();

    }

}

void CMMFRadioBackendEngine::StopRadio()

{

    if (iRadioPlayerUtility)

    {

        iRadioPlayerUtility->Stop();

    }

}

{

    TInt ret = KErrNotFound;

    TUint currentMode;

    ret = GetForcedMonoReception(currentMode);

    if (ret != XA_RESULT_SUCCESS)

    if (iFmTunerUtility)

    {

        if (aForcedMono == XA_STEREOMODE_MONO)

        {

            iForceStereo = EFalse;

            ret = iFmTunerUtility->ForceMonoReception(ETrue);

        }

        else if (aForcedMono == XA_STEREOMODE_STEREO)

        {

            iForceStereo = ETrue;

            if (currentMode == XA_STEREOMODE_AUTO) // Transition from Auto to Stereo doesn't require Utility call:

            {

                MrftoForcedMonoChange(ETrue);

            }

            else

            {

                ret = iFmTunerUtility->ForceMonoReception(EFalse);

            }

        }

        else // (aForcedMono == XA_STEREOMODE_AUTO)

        {

            iForceStereo = EFalse;

            if (currentMode == XA_STEREOMODE_STEREO) // Transition from Stereo to Auto doesn't require Utility call:

            {

                MrftoForcedMonoChange(EFalse);

            }

            else

            {

                ret = iFmTunerUtility->ForceMonoReception(EFalse);

            }

        }

    }

}

XAresult CMMFRadioBackendEngine::SetForceMonoFlag() 

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetForcedMonoReception(forceMono);

        if (ret == KErrNotReady)

        {

            // For Radio Utility Default value = XA_STEREOMODE_STEREO

            iForceStereo = ETrue;

        }

    }

    {

        iForceStereo = EFalse;

    }

    else

    {

        iForceStereo = ETrue;

    }

}

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetSquelch(aSquelch);

    }

}

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->SetSquelch(aSquelch);

    }

}

void CMMFRadioBackendEngine::SetAdaptContext(void * adaptcontext)

{

    iAdaptContext = (XAAdaptationBaseCtx*)adaptcontext;

}

    {

    XAresult status(XA_RESULT_SUCCESS);

    switch(error)

        {

        case KErrNone:

            status = XA_RESULT_SUCCESS;

            break;

        // to do: investigate and add other possible errors:

       /* case XA_RESULT_PRECONDITIONS_VIOLATED:

            break;

        case XA_RESULT_PARAMETER_INVALID:

            break;

        case XA_RESULT_RESOURCE_ERROR:

            break;

        case XA_RESULT_RESOURCE_LOST:

            break;

        case XA_RESULT_IO_ERROR:

            break;

        case XA_RESULT_BUFFER_INSUFFICIENT:

            break;

        case XA_RESULT_CONTENT_CORRUPTED:

            break;

        case XA_RESULT_CONTENT_UNSUPPORTED:

            break;

        case XA_RESULT_CONTENT_NOT_FOUND:

            break;

        case XA_RESULT_PERMISSION_DENIED:

            break;

        case XA_RESULT_FEATURE_UNSUPPORTED:

            break;

        case XA_RESULT_INTERNAL_ERROR:

            break;

        case XA_RESULT_OPERATION_ABORTED:

            break;

        case XA_RESULT_CONTROL_LOST:

            break;

            */

        default:

        } // end switch

    return status;

    }

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

// CMMFRadioBackendEngine::MrpeoPresetChanged

// Observer for Presets

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

void CMMFRadioBackendEngine::MrpeoPresetChanged(

    TPresetChangeEvent /*aChange*/,

    TInt /*aIndex*/ )

{

}

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

// CMMFRadioBackendEngine::MrftoSquelchChange

//

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

//

void CMMFRadioBackendEngine::MrftoSquelchChange(

    TBool aSquelch)

{

//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSquelchChange: aSquelch =  %d", aSquelch);

// Currently, Openmaxal doesn't have event defined to handle this callback

}

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

// CMMFRadioBackendEngine::MrftoForcedMonoChanged

// Called when a client enables/disabled forced mono reception

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

//

void CMMFRadioBackendEngine::MrftoForcedMonoChange(

    TBool aForcedMono )

{

//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoForcedMonoChange: aForcedMono =  %d", aForcedMono);

    XARadioItfAdapt_StereoStatusChange((XAAdaptationBaseCtx*)iAdaptContext, aForcedMono);

}

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

// CMMFRadioBackendEngine::MrftoFrequencyChange

// Called when the tuned frequency changes

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

//

void CMMFRadioBackendEngine::MrftoFrequencyChange(

    TInt aNewFrequency)

{

//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoFrequencyChange: aNewFrequency =  %d", aNewFrequency);

    XARadioItfAdapt_FrequencyChange((XAAdaptationBaseCtx*)iAdaptContext, aNewFrequency);

}

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

// CMMFRadioBackendEngine::MrftoFrequencyRangeChange

//

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

//

void CMMFRadioBackendEngine::MrftoFrequencyRangeChange(

    TFmRadioFrequencyRange aNewRange )