/*

* 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 "xanokiavolumeextitfadaptationmmf.h"

#include "xanokialinearvolumeitfadaptationmmf.h"

#include "xaplayitfadaptationmmf.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;

}

void CMMFRadioBackendEngine::StationSeek(XAboolean aUpwards)

{

    if (iFmTunerUtility)

    {

    iFmTunerUtility->StationSeek(aUpwards);

    }

}

void CMMFRadioBackendEngine::SetFrequency(TInt aFreq)

{

  DEBUG_API_A1("CMMFRadioBackendEngine::SetFrequency: %d", aFreq);

    if (iFmTunerUtility)

    {

    iFmTunerUtility->SetFrequency(aFreq);

    }

}

TInt CMMFRadioBackendEngine::GetFrequency(TInt& aFreq)

{

  DEBUG_API("CMMFRadioBackendEngine::GetFrequency");

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

    ret = iFmTunerUtility->GetFrequency(aFreq);

    if (ret != KErrNone)

    {

        aFreq = iDefaultFrequency;

        ret = KErrNone;

    }

    }

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

//  RDebug::Print(_L("CMMFRadioBackendEngine::GetFrequency RET: %d"), ret);

    return ret;

}

TInt CMMFRadioBackendEngine::GetSignalStrength(TInt& aSignalStrength)

{

    TInt ret = KErrNotFound;

    if (iFmTunerUtility)

    {

    ret = iFmTunerUtility->GetSignalStrength(aSignalStrength);

    }

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

//  RDebug::Print(_L("CMMFRadioBackendEngine::GetSignalStrength RET: %d"), ret);

    return 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 CMMFRadioBackendEngine::GetFreqRange(TFmRadioFrequencyRange& 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;

        }

    }

  DEBUG_API_A1("CMMFRadioBackendEngine::GetFreqRange RET: %d", ret);

//  RDebug::Print(_L("CMMFRadioBackendEngine::GetFreqRange RET: %d"), ret);

  return ret;

}

TInt CMMFRadioBackendEngine::GetFreqRangeProperties(TFmRadioFrequencyRange& aRange, TInt& aMinFreq, TInt& aMaxFreq)

{

    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;

        }

    }

  DEBUG_API_A1("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d", ret);

//  RDebug::Print(_L("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d"), ret);

  return ret;

}

TInt CMMFRadioBackendEngine::GetMaxVolume(TInt& aMaxVol)

{

    TInt ret = KErrNotFound;

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->GetMaxVolume(aMaxVol);

    }

  return ret;

}

TInt CMMFRadioBackendEngine::SetVolume(TInt aVol)

{

    TInt ret = KErrNotFound;

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->SetVolume(aVol);

    }

  return ret;

}

TInt CMMFRadioBackendEngine::SetMute(XAboolean aMute)

{

    TInt ret = KErrNotFound;

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->Mute(aMute);

    }

  return ret;

}

TInt CMMFRadioBackendEngine::GetVolume(TInt& aVol)

{

    TInt ret = KErrNotFound;

    if (iRadioPlayerUtility)

    {

        ret = iRadioPlayerUtility->GetVolume(aVol);

    }

  return ret;

}

TInt CMMFRadioBackendEngine::GetForcedMonoReception(XAuint32& aForcedMono)

{

    TInt ret = KErrNotFound;

    TBool forceMono(EFalse);

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetForcedMonoReception(forceMono);

        if (ret == KErrNotReady)

        {

            aForcedMono = XA_STEREOMODE_AUTO; // Radio Utility Default value

            return KErrNone;

        }

    }

    if (forceMono)

    {

        aForcedMono = XA_STEREOMODE_MONO;

    }

    else

    {

        if (iForceStereo)

            aForcedMono = XA_STEREOMODE_STEREO;

        else

            aForcedMono = XA_STEREOMODE_AUTO;

    }

  return ret;

}

void CMMFRadioBackendEngine::PlayRadio()

{

    if (iRadioPlayerUtility)

    {

        iRadioPlayerUtility->Play();

    }

}

void CMMFRadioBackendEngine::StopRadio()

{

    if (iRadioPlayerUtility)

    {

        iRadioPlayerUtility->Stop();

    }

}

TInt CMMFRadioBackendEngine::ForceMonoReception(XAuint32 aForcedMono)

{

    TInt ret = KErrNotFound;

    XAuint32 currentMode;

    ret = GetForcedMonoReception(currentMode);

    if (ret != XA_RESULT_SUCCESS)

        return ret;

    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);

            }

        }

    }

  DEBUG_API_A1("CMMFRadioBackendEngine::ForceMonoReception RET: %d", ret);

 // RDebug::Print(_L("CMMFRadioBackendEngine::ForceMonoReception RET: %d"), ret);

  return ret;

}

XAresult CMMFRadioBackendEngine::SetForceMonoFlag()

{

    TInt ret = KErrNotFound;

    TBool forceMono(EFalse);

    if (iFmTunerUtility)

    {

        ret = iFmTunerUtility->GetForcedMonoReception(forceMono);

        if (ret == KErrNotReady)

        {

            // For Radio Utility Default value = XA_STEREOMODE_STEREO

            iForceStereo = ETrue;

            return KErrNone;

        }

    }

    if (forceMono == XA_STEREOMODE_MONO)

    {

        iForceStereo = EFalse;

    }

    else

    {

        iForceStereo = ETrue;

    }

  return ret;

}

XAresult CMMFRadioBackendEngine::SetRadioAdaptContext(void * adaptcontext)

{

    iRadioAdaptContext = adaptcontext;

    return XA_RESULT_SUCCESS;

}

XAresult CMMFRadioBackendEngine::SetPlayerAdaptContext(void * adaptcontext)

{

    iPlayerAdaptContext = adaptcontext;

    return XA_RESULT_SUCCESS;

}

XAresult TranslateError(TInt error)

    {

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

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

            break;

        case XA_RESULT_OPERATION_ABORTED:

            break;

        case XA_RESULT_CONTROL_LOST:

            break;

            */

        default:

            break;

        } // end switch

    return status;

    }

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

// CMMFRadioBackendEngine::MrpeoPresetChanged

// Observer for Presets

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

void CMMFRadioBackendEngine::MrpeoPresetChanged(

    TPresetChangeEvent /*aChange*/,

    TInt /*aIndex*/ )

{

}

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

// CMMFRadioBackendEngine::MrftoSquelchChange

//

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

//

void CMMFRadioBackendEngine::MrftoSquelchChange(

    TBool /*aSquelch*/ )

{

}

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

// CMMFRadioBackendEngine::MrftoForcedMonoChanged

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

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

//

void CMMFRadioBackendEngine::MrftoForcedMonoChange(

    TBool aForcedMono )

{

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

//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoForcedMonoChange: aForcedMono = %d"), aForcedMono);

    XARadioItfAdapt_StereoStatusChange((XAAdaptationBaseCtx*)iRadioAdaptContext, aForcedMono);

}

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

// CMMFRadioBackendEngine::MrftoFrequencyChange

// Called when the tuned frequency changes

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

//

void CMMFRadioBackendEngine::MrftoFrequencyChange(

    TInt aNewFrequency)

{

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

 // RDebug::Print(_L("CMMFRadioBackendEngine::MrftoFrequencyChange aNewFrequency = %d"), aNewFrequency);

    XARadioItfAdapt_FrequencyChange((XAAdaptationBaseCtx*)iRadioAdaptContext, aNewFrequency);

}

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

// CMMFRadioBackendEngine::MrftoFrequencyRangeChange

//

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

//

void CMMFRadioBackendEngine::MrftoFrequencyRangeChange(

    TFmRadioFrequencyRange aNewRange )

{

    DEBUG_API_A1("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange =  %d", aNewRange);

//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange = %d"), aNewRange);

    XARadioItfAdapt_FrequencyRangeChange((XAAdaptationBaseCtx*)iRadioAdaptContext, aNewRange);

}

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

// CMMFRadioBackendEngine::MrftoOfflineModeStatusChange

// Called when offline mode status changes

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

//

void CMMFRadioBackendEngine::MrftoOfflineModeStatusChange(

    TBool /*aOfflineMode*/ )

{

}

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

// CMMFRadioBackendEngine::MrftoAntennaStatusChange

// Called when antenna status changes.

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

//

void CMMFRadioBackendEngine::MrftoAntennaStatusChange(

    TBool /*aAttached*/ )

{

}