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