/*

* Copyright (c) 2005-2007 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:  This class is used to control tuner

*

*/

// INCLUDE FILES

#include    "CAMMSTunerControl.h"

#include    "CAMMSTunerPlayer.h"

#include    "CAMMSTunerPresetsHandler.h"

#include    "TAMMSTunerPreset.h"

#include    "AMMSTunerFactory.h"

#include    <tuner.h>

#include    <jdebug.h>

// CONSTANTS

_LIT(KControlImplName, "com.nokia.amms.control.tuner.TunerControlImpl");

_LIT(KControlPublicName, "javax.microedition.amms.control.tuner.TunerControl");

const TInt KStereoModeMono   = 1;

const TInt KStereoModeStereo = 2;

const TInt KStereoModeAuto   = 3;

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

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

// CAMMSTunerControl::CAMMSTunerControl

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAMMSTunerControl::CAMMSTunerControl()

{

}

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

// CAMMSTunerControl::NewL

// Two-phased constructor.

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

//

CAMMSTunerControl* CAMMSTunerControl::NewL()

{

    CAMMSTunerControl* self = new(ELeave) CAMMSTunerControl;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

// CAMMSTunerControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAMMSTunerControl::ConstructL()

{

    DEBUG("CAMMSTunerControl::ConstructL +");

    iTunerUtility = CMMTunerUtility::NewL(*this,

                                          CMMTunerUtility::ETunerBandFm,

                                          1,

                                          CMMTunerUtility::ETunerAccessPriorityNormal);

    iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait();

    iPresetsHandler = CAMMSTunerPresetsHandler::NewL();

    iMinFreq = MinFreqL();

    iMaxFreq = MaxFreqL();

    DEBUG("CAMMSTunerControl::ConstructL -");

}

// Destructor

CAMMSTunerControl::~CAMMSTunerControl()

{

    DEBUG("CAMMSTunerControl::~CAMMSTunerControl +");

    delete iTunerUtility;

    delete iActiveSchedulerWait;

    delete iPresetsHandler;

    DEBUG("CAMMSTunerControl::~CAMMSTunerControl -");

}

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

// CAMMSTunerControl::TunerUtility()

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

CMMTunerUtility* CAMMSTunerControl::TunerUtility()

{

    DEBUG("CAMMSTunerControl::TunerUtility");

    return iTunerUtility;

}

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

// CAMMSTunerControl::MinFreq()

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

TInt CAMMSTunerControl::MinFreqL()

{

    DEBUG("CAMMSTunerControl::MinFreqL +");

    TFrequency minFreq;

    TFrequency maxFreq;

    User::LeaveIfError(iTunerUtility->GetFrequencyBandRange(minFreq,

                       maxFreq));

    DEBUG_INT("CAMMSTunerControl::MinFreqL = %d", minFreq.iFrequency);

    return minFreq.iFrequency;

}

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

// CAMMSTunerControl::MaxFreq()

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

TInt CAMMSTunerControl::MaxFreqL()

{

    DEBUG("CAMMSTunerControl::MaxFreqL +");

    TFrequency minFreq;

    TFrequency maxFreq;

    User::LeaveIfError(iTunerUtility->GetFrequencyBandRange(minFreq,

                       maxFreq));

    DEBUG_INT("CAMMSTunerControl::MaxFreqL = %d", maxFreq.iFrequency);

    return maxFreq.iFrequency;

}

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

// CAMMSTunerControl::SetFrequency()

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

void CAMMSTunerControl::SetFrequencyL(TInt aFreq)

{

    DEBUG("CAMMSTunerControl::SetFrequency +");

    if (aFreq < iMinFreq || aFreq > iMaxFreq)

    {

        User::Leave(KErrArgument);

    }

    TFrequency freq = TFrequency(aFreq);

    TUint32 state = 0;

    iTunerUtility->GetState(state);

    DEBUG_INT("CAMMSTunerControl::SetFrequency, state = %d", state);

    DEBUG_INT("CAMMSTunerControl::SetFrequency = %d", freq.iFrequency);

    iTunerUtility->Tune(freq);

    if (!iActiveSchedulerWait->IsStarted())

    {

        iActiveSchedulerWait->Start();  // CSI: 10 Active object state already checked. #

    }

    DEBUG("CAMMSTunerControl::SetFrequency -");

}

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

// CAMMSTunerControl::Frequency()

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

TInt CAMMSTunerControl::FrequencyL()

{

    DEBUG("CAMMSTunerControl::Frequency +");

    TFrequency freq;

    User::LeaveIfError(iTunerUtility->GetFrequency(freq));

    TInt frequency = freq.iFrequency;

    DEBUG_INT("CAMMSTunerControl::Frequency frequency = %d", frequency);

    return frequency;

}

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

// CAMMSTunerControl::SeekL()

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

TInt CAMMSTunerControl::SeekL(TInt aStartFreq, TBool aUpwards)

{

    DEBUG("CAMMSTunerControl::SeekL +");

    if (aStartFreq < iMinFreq || aStartFreq > iMaxFreq)

    {

        User::Leave(KErrArgument);

    }

    if (aUpwards)

    {

        iTunerUtility->StationSeek(CMMTunerUtility::ESearchDirectionUp);

        if (!iActiveSchedulerWait->IsStarted())

        {

            iActiveSchedulerWait->Start();  // CSI: 10 Active object state already checked. #

        }

    }

    else

    {

        iTunerUtility->StationSeek(CMMTunerUtility::ESearchDirectionDown);

        if (!iActiveSchedulerWait->IsStarted())

        {

            iActiveSchedulerWait->Start();  // CSI: 10 Active object state already checked. #

        }

    }

    return FrequencyL();

}

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

// CAMMSTunerControl::SquelchL()

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

TBool CAMMSTunerControl::SquelchL()

{

    DEBUG("CAMMSTunerControl::SquelchL +");

    TBool enabled = EFalse;

    User::LeaveIfError(iTunerUtility->GetSquelch(enabled));

    return enabled;

}

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

// CAMMSTunerControl::SetSquelchL()

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

void CAMMSTunerControl::SetSquelchL(TBool aSquelch)

{

    DEBUG("CAMMSTunerControl::SetSquelchL +");

    User::LeaveIfError(iTunerUtility->SetSquelch(aSquelch));

}

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

// CAMMSTunerControl::SignalStrengthL()

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

TInt CAMMSTunerControl::SignalStrengthL()

{

    DEBUG("CAMMSTunerControl::SignalStrengthL +");

    TInt maxSignalStrength = 0;

    TInt signalStrength = 0;

    User::LeaveIfError(iTunerUtility->GetMaxSignalStrength(maxSignalStrength));

    DEBUG_INT("CAMMSTunerControl::SignalStrengthL, maxSignalStrength = %d", maxSignalStrength);

    User::LeaveIfError(iTunerUtility->GetSignalStrength(signalStrength));

    DEBUG_INT("CAMMSTunerControl::SignalStrengthL, signalStrength = %d", signalStrength);

    if (maxSignalStrength > 0)

    {

        return signalStrength / maxSignalStrength * 100; // CSI: 47 signal strength must be between 0 and 100 #

    }

    return KErrNotSupported;

}

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

// CAMMSTunerControl::StereoModeL()

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

TInt CAMMSTunerControl::StereoModeL()

{

    DEBUG("CAMMSTunerControl::StereoModeL +");

    TBool mono = EFalse;

    TBool stereo = EFalse;

    User::LeaveIfError(iTunerUtility->GetForcedMonoReception(mono));

    if (mono)

    {

        return KStereoModeMono;

    }

    //User::LeaveIfError( iTunerUtility->IsStereoSignal( stereo ) );

    TInt err = iTunerUtility->IsStereoSignal(stereo);

    //this is for emulator testing, FIX IT

    if (err == KErrNotReady)

    {

        return KStereoModeAuto;

    }

    else if (err != KErrNone)

    {

        User::LeaveIfError(err);

    }

    if (stereo)

    {

        return KStereoModeStereo;

    }

    return KStereoModeAuto;

}

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

// CAMMSTunerControl::SetStereoMode()

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

void CAMMSTunerControl::SetStereoModeL(TInt aMode)

{

    DEBUG("CAMMSTunerControl::SetStereoModeL +");

    if (aMode == KStereoModeMono)

    {

        User::LeaveIfError(iTunerUtility->ForceMonoReception(ETrue));

    }

    if (aMode == KStereoModeStereo)

    {

        User::LeaveIfError(iTunerUtility->ForceMonoReception(EFalse));

        TBool stereo = EFalse;

        User::LeaveIfError(iTunerUtility->IsStereoSignal(stereo));

        if (!stereo)

        {

            User::Leave(KErrNotSupported);

        }

    }

    if (aMode == KStereoModeAuto)

    {

        User::LeaveIfError(iTunerUtility->ForceMonoReception(EFalse));

    }

}

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

// CAMMSTunerControl::UsePresetL()

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

void CAMMSTunerControl::UsePresetL(TInt aPreset)

{

    DEBUG("CAMMSTunerControl::UsePresetL +");

    TAMMSTunerPreset tunerPreset;

    //get presets

    iPresetsHandler->GetPresetL(aPreset, tunerPreset);

    //set presets to tunerutility

    SetFrequencyL(tunerPreset.PresetFrequency());

    SetStereoModeL(tunerPreset.PresetStereoMode());

}

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

// CAMMSTunerControl::SetPresetL()

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

void CAMMSTunerControl::SetPresetL(TInt aPreset)

{

    DEBUG("CAMMSTunerControl::SetPresetL1 +");

    TAMMSTunerPreset tunerPreset;

    //get current frequency

    tunerPreset.SetPresetFrequency(FrequencyL());

    //get current stereo mode

    tunerPreset.SetPresetStereoMode(StereoModeL());

    iPresetsHandler->SavePresetL(aPreset, tunerPreset);

}

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

// CAMMSTunerControl::SetPresetL()

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

void CAMMSTunerControl::SetPresetL(TInt aPreset,

                                   TInt aFrequency,

                                   TInt aStereoMode)

{

    DEBUG("CAMMSTunerControl::SetPresetL2 +");

    TAMMSTunerPreset tunerPreset;

    tunerPreset.SetPresetFrequency(aFrequency);

    tunerPreset.SetPresetStereoMode(aStereoMode);

    iPresetsHandler->SavePresetL(aPreset, tunerPreset);

}

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

// CAMMSTunerControl::PresetFrequencyL()

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

TInt CAMMSTunerControl::PresetFrequencyL(TInt aPreset)

{

    DEBUG("CAMMSTunerControl::PresetFrequencyL +");

    TAMMSTunerPreset tunerPreset;

    iPresetsHandler->GetPresetL(aPreset, tunerPreset);

    return tunerPreset.PresetFrequency();

}

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

// CAMMSTunerControl::PresetStereoModeL()

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

TInt CAMMSTunerControl::PresetStereoModeL(TInt aPreset)

{

    DEBUG("CAMMSTunerControl::PresetStereoModeL +");

    TAMMSTunerPreset tunerPreset;

    iPresetsHandler->GetPresetL(aPreset, tunerPreset);

    return tunerPreset.PresetStereoMode();

}

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

// CAMMSTunerControl::SetPresetNameL()

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

void CAMMSTunerControl::SetPresetNameL(TInt aPreset, const TDesC* aPresetName)

{

    DEBUG("CAMMSTunerControl::SetPresetNameL +");

    TAMMSTunerPreset tunerPreset;

    iPresetsHandler->GetPresetL(aPreset, tunerPreset);

    tunerPreset.SetPresetName(aPresetName);

    iPresetsHandler->SavePresetL(aPreset, tunerPreset);

}

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

// CAMMSTunerControl::GetPresetNameL()

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

void CAMMSTunerControl::GetPresetNameL(TInt aPreset, TPtrC* aPresetName)

{

    DEBUG("CAMMSTunerControl::GetPresetNameL +");

    TAMMSTunerPreset tunerPreset;

    iPresetsHandler->GetPresetL(aPreset, tunerPreset);

    aPresetName->Set(tunerPreset.PresetName());

}

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

// CAMMSTunerControl::ClassName()

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

const TDesC& CAMMSTunerControl::ClassName() const

{

    return KControlImplName;

}

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

// CAMMSTunerControl::PublicClassName()

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

const TDesC& CAMMSTunerControl::PublicClassName() const

{

    return KControlPublicName;

}

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

// CAMMSTunerControl::MToTuneComplete()

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

void CAMMSTunerControl::MToTuneComplete(TInt aError)

{

    if (iActiveSchedulerWait->IsStarted())

    {

        DEBUG("CAMMSTunerControl::MToTuneComplete AsyncStop");

        iActiveSchedulerWait->AsyncStop();

    }

    DEBUG_INT("CAMMSTunerControl::MToTuneComplete ERROR = %d", aError);

}

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

// CAMMSTunerControl::MTcoFrequencyChanged

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

void CAMMSTunerControl::MTcoFrequencyChanged(const TFrequency& /*aOldFrequency*/,

        const TFrequency& /*aNewFrequency*/)

{

    DEBUG("CAMMSTunerControl::MTcoFrequencyChanged");

}

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

// CAMMSTunerControl::MTcoStateChanged

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

void CAMMSTunerControl::MTcoStateChanged(const TUint32& /*aOldState*/,

        const TUint32& /*aNewState*/)

{

    DEBUG("CAMMSTunerControl::MTcoStateChanged");

}

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

// CAMMSTunerControl::MTcoAntennaDetached

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

void CAMMSTunerControl::MTcoAntennaDetached()

{

    DEBUG("CAMMSTunerControl::MTcoAntennaDetached");

}

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

// CAMMSTunerControl::MTcoAntennaAttached

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

void CAMMSTunerControl::MTcoAntennaAttached()

{

    DEBUG("CAMMSTunerControl::MTcoAntennaAttached");

}

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

// CAMMSTunerControl::FlightModeChanged

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

void CAMMSTunerControl::FlightModeChanged(TBool /*aFlightMode*/)

{

    DEBUG("CAMMSTunerControl::FlightModeChanged");

}

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

// CAMMSTunerControl::MTsoStereoReceptionChanged

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

void CAMMSTunerControl::MTsoStereoReceptionChanged(TBool /*aStereo*/)

{

    DEBUG("CAMMSTunerControl::MTsoStereoReceptionChanged");

}

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

// CAMMSTunerControl::MTsoForcedMonoChanged

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

void CAMMSTunerControl::MTsoForcedMonoChanged(TBool /*aForcedMono*/)

{

    DEBUG("CAMMSTunerControl::MTsoForcedMonoChanged");

}

//  End of File