/*
* 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 create tuner player and control
*
*/



// INCLUDE FILES
#include    "AMMSTunerFactory.h"
#include    "CAMMSTunerPlayer.h"
#include    "CAMMSTunerControl.h"
//#include    "CAMMSTunerVolumeControl.h"
#include    <CMMAPlayerProperties.h>

#include    <e32std.h>
#include    <e32math.h>
#include    <jdebug.h>

// CONSTANTS
_LIT(KFreqParam, "f");

_LIT(KModulationParam, "mod");

_LIT(KStereoModeParam, "st");
MMA_PARAMETER_STR(KStereoModeParamMono, "mono");
MMA_PARAMETER_STR(KStereoModeParamStereo, "stereo");
MMA_PARAMETER_STR(KStereoModeParamAuto, "auto");
MMA_PARAMETER_ARRAY(KValidStereoModeValues)
{
    {
        &KStereoModeParamMono
    }, {&KStereoModeParamStereo}, {&KStereoModeParamAuto}
};

_LIT(KProgramIdParam, "id");
_LIT(KPresetParam, "preset");

_LIT(KModulationFm, "fm");

_LIT(KStereoModeMono, "mono");
_LIT(KStereoModeStereo, "stereo");
_LIT(KStereoModeAuto, "auto");

const TInt KMegaHertzChar = 'M';
const TInt KKiloHertzChar = 'k';
const TInt KFreqDotChar   = '.';

const TInt KMegaHzMultiplier = 1000000;
const TInt KKiloHzMultiplier = 1000;

const TInt KStereoModeMonoInt   = 1;
const TInt KStereoModeStereoInt = 2;
const TInt KStereoModeAutoInt   = 3;

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

// Destructor
AMMSTunerFactory::~AMMSTunerFactory()
{

}


// -----------------------------------------------------------------------------
// AMMSTunerFactory::CreatePlayerL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void AMMSTunerFactory::CreatePlayerL(CAMMSTunerPlayer** aTunerPlayer,
                                     const TDesC* aLocatorParams)
{
    DEBUG("AMMSTunerFactory::CreatePlayerL +");

    TInt frequency = 0;
    TInt stereoMode = 0;
    TInt preset = 0;

    if (aLocatorParams->Length() != 0)
    {
        DEBUG("AMMSTunerFactory::CreatePlayerL 1");
        ParseParamsL(aLocatorParams, frequency, stereoMode, preset);
    }

    //create tunercontrol
    CAMMSTunerControl* tunerControl = CAMMSTunerControl::NewL();
    CleanupStack::PushL(tunerControl);

    //set values to tunercontrol
    if (frequency > 0)
    {
        tunerControl->SetFrequencyL(frequency);
    }

    if (frequency == 0)
    {
        //by default frequency is fm modulation's min freq
        tunerControl->SetFrequencyL(tunerControl->MinFreqL());
    }

    if (stereoMode > 0)
    {
        tunerControl->SetStereoModeL(stereoMode);
    }

    if (preset > 0)
    {
        tunerControl->UsePresetL(preset);
    }

    //create tunerplayer
    *aTunerPlayer = CAMMSTunerPlayer::NewL(tunerControl);

    //create tunervolumeconrol
    //CAMMSTunerVolumeControl* tunerVolumeControl = CAMMSTunerVolumeControl::NewL( *aTunerPlayer );

    //add controls to player
    (*aTunerPlayer)->AddControlL(tunerControl);
    //(*aTunerPlayer)->AddControlL( tunerVolumeControl );
    CleanupStack::Pop(tunerControl);
    DEBUG("AMMSTunerFactory::CreatePlayerL -");
}

// -----------------------------------------------------------------------------
// AMMSTunerFactory::ParseParamsL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void AMMSTunerFactory::ParseParamsL(const TDesC* aLocatorParams,
                                    TInt& aFrequency,
                                    TInt& aStereoMode,
                                    TInt& aPreset)
{
    DEBUG("AMMSTunerFactory::ParseParamsL +");
    CMMAParameterRuleSet* rules = CMMAParameterRuleSet::NewLC();

    //freq rule
    TMMAParameterRuleDes freqRule(KFreqParam);
    rules->AppendRuleL(&freqRule);

    //modulation rule
    TMMAParameterRuleDes modulationRule(KModulationParam);
    rules->AppendRuleL(&modulationRule);

    //stereo mode rule
    TMMAParameterRuleDes stereoModeRule(KStereoModeParam, KValidStereoModeValues,
                                        MMA_PARAMETER_ARRAY_SIZE(KValidStereoModeValues));
    rules->AppendRuleL(&stereoModeRule);

    //preset rule KMinTInt-KMaxTInt
    TMMAParameterRuleInt presetRule(KPresetParam);
    rules->AppendRuleL(&presetRule);

    //id rule
    TMMAParameterRuleDes idRule(KProgramIdParam);
    rules->AppendRuleL(&idRule);

    CMMAPlayerProperties* properties = CMMAPlayerProperties::NewL(*aLocatorParams, *rules);
    CleanupStack::PushL(properties);

    // validating properties
    properties->ValidateL();

    //get freq
    TPtrC freq(NULL, 0);
    properties->GetProperty(KFreqParam, freq);
    //parse frequency
    if (freq.Length() != 0)
    {
        aFrequency = ParseFreqL(freq);
    }

    //get modulation
    TPtrC modulation(NULL, 0);
    properties->GetProperty(KModulationParam, modulation);
    if (modulation.Length() != 0)
    {
        // only fm modulation is supported
        if (modulation.Compare(KModulationFm) != 0)
        {
            User::Leave(KErrNotSupported);
        }
    }

    //get stereo mode
    TPtrC stereoMode(NULL, 0);
    properties->GetProperty(KStereoModeParam, stereoMode);
    if (stereoMode.Compare(KStereoModeMono) == 0)
    {
        aStereoMode = KStereoModeMonoInt;
    }
    else if (stereoMode.Compare(KStereoModeStereo) == 0)
    {
        aStereoMode = KStereoModeStereoInt;
    }
    else if (stereoMode.Compare(KStereoModeAuto) == 0)
    {
        aStereoMode = KStereoModeAutoInt;
    }

    //get preset
    properties->GetProperty(KPresetParam, aPreset);

    //get id
    TPtrC id(NULL, 0);
    properties->GetProperty(KProgramIdParam, id);
    if (id.Length() != 0)
    {
        // id is not supported
        User::Leave(KErrNotSupported);
    }

    CleanupStack::PopAndDestroy(properties);
    CleanupStack::PopAndDestroy(rules);
    DEBUG("AMMSTunerFactory::ParseParamsL -");
}

// -----------------------------------------------------------------------------
// AMMSTunerFactory::ParseFreqL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt AMMSTunerFactory::ParseFreqL(const TPtrC aFrequency)
{
    DEBUG("AMMSTunerFactory::ParseFreqL +");
    TReal freqReal = 0;

    //is value MHz or kHz or just hertz
    TInt freqPrefixMPos = aFrequency.Locate(KMegaHertzChar);
    TInt freqPrefixKPos = aFrequency.Locate(KKiloHertzChar);

    if (freqPrefixMPos != KErrNotFound)
    {
        //there is a M
        TPtrC hertz = aFrequency.Left(freqPrefixMPos);
        //TPtrC -> TReal
        TReal value = TDesCToTRealL(hertz);

        freqReal = value * KMegaHzMultiplier;
    }
    else if (freqPrefixKPos != KErrNotFound)
    {
        //there is a k
        TPtrC hertz = aFrequency.Left(freqPrefixKPos);
        //TPtrC -> TReal
        TReal value = TDesCToTRealL(hertz);

        freqReal = value * KKiloHzMultiplier;
    }
    else
    {
        //parameter value is simply hertz, there is no M or k
        //TPtrC -> TReal
        freqReal = TDesCToTRealL(aFrequency);
    }
    TInt32 freqInt = 0;
    //TReal -> TInt
    TInt err = Math::Int(freqInt, freqReal);
    if (err != KErrNone)
    {
        User::Leave(KErrArgument);
    }

    return freqInt;
}

// -----------------------------------------------------------------------------
// AMMSTunerFactory::TDesCToTRealL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TReal AMMSTunerFactory::TDesCToTRealL(const TPtrC aHertz)
{
    DEBUG("AMMSTunerFactory::TDesCToTRealL +");
    TReal valueReal = 0;
    TLex lex(aHertz);
    if ((lex.Val(valueReal, KFreqDotChar) != KErrNone) ||
            !lex.Eos())
    {
        User::Leave(KErrArgument);
    }
    return valueReal;
}

//  End of File