/*
* 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:  Virtualizes audio channels.
*
*/



// INCLUDE FILES
#include <jdebug.h>
#include "cammsemcaudiovirtualizercontrol.h"


// CONSTANTS
const TInt KAMMSEMCDefaultStereoWideningLevel = 100;

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


// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
CAMMSEMCAudioVirtualizerControl* CAMMSEMCAudioVirtualizerControl::NewLC(
    CMMAPlayer* aPlayer)
{
    CAMMSEMCAudioVirtualizerControl* self =
        new(ELeave) CAMMSEMCAudioVirtualizerControl(aPlayer);

    CleanupStack::PushL(self);
    self->ConstructL();

    return self;
}

// Destructor
CAMMSEMCAudioVirtualizerControl::~CAMMSEMCAudioVirtualizerControl()
{
    DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl::~CAMMSEMCAudioVirtualizerControl");

    // Perform DeallocateControl, if the state change has not yet performed it.
    DeallocateControl();
    if (iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility)
        delete iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility;
    delete iPresetNames;

}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::SetPresetL
// Sets the effect according to the given preset.
// -----------------------------------------------------------------------------
//
void CAMMSEMCAudioVirtualizerControl::SetPresetL(const TDesC& aPreset)
{

    DEBUG_STR("AMMS::CAMMSEMCAudioVirtualizerControl::SetPresetL \"%S\"",
              aPreset);
    CStereoWidening *iStereoWidening = NULL;
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->PrepareEmptyStereoWideningUtilitiesL();
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->GetPresetNamesL(*iPresetNames);
    TInt presetPosition = 0;
    TInt findPreset = iPresetNames->Find(aPreset, presetPosition);
    if (findPreset == 0)  // Find returns zero, if a matching element is found.
    {
        iStereoWidening = iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->GetStereoWideningAtPresetIndexL(presetPosition);
        iCurrentPreset = presetPosition;
    }
    else
    {
        iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->DeleteEmptyStereoWideningUtilities();
        User::Leave(KErrArgument);
    }

    if (!iStereoWidening)
    {
        iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->DeleteEmptyStereoWideningUtilities();
        return;
    }
    //Get all preset data here
    TUint8 iStereoWideningLevel = iStereoWidening->StereoWideningLevel();
    // Set all preset data to EMC
    iMStereoWideningControl->SetStereoWideningLevel(iStereoWideningLevel);
    iMStereoWideningControl->Apply();
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->DeleteEmptyStereoWideningUtilities();
    DEBUG_STR("AMMS::CAMMSEMCAudioVirtualizerControl::SetPresetL \"%S\" GetPresetL OK",
              aPreset);
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::PresetNamesL
// Gets the available preset names.
// -----------------------------------------------------------------------------
//
const CDesCArray& CAMMSEMCAudioVirtualizerControl::PresetNamesL()
{
    // Returns an array of all preset names (pre-defined and user-defined).
    // The pre-defined presets are in the beginning of the list.
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->PrepareEmptyStereoWideningUtilitiesL();
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->GetPresetNamesL(*iPresetNames);
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->DeleteEmptyStereoWideningUtilities();
    return *iPresetNames;
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::PresetL
// Gets the current preset.
// -----------------------------------------------------------------------------
//
const TDesC& CAMMSEMCAudioVirtualizerControl::PresetL()
{
    //if no preset is set, return null
    if (iCurrentPreset < 0)
    {
        return KNullDesC;
    }

    else
    {
        // Retrieves a Preset with the given index from the utility class
        iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->PrepareEmptyStereoWideningUtilitiesL();
        iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->GetPresetAtIndexL(iPresetName , iCurrentPreset);
        iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->DeleteEmptyStereoWideningUtilities();
        return iPresetName;
    }
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::SetEnabledL
// Enables/disables the effect.
// -----------------------------------------------------------------------------
//
void CAMMSEMCAudioVirtualizerControl::SetEnabledL(TBool aEnable)
{
    if (aEnable)
    {
        // Enable the effect.
        DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl::SetEnabledL(true).");
        iMStereoWideningControl->Enable();
        iMStereoWideningControl->SetStereoWideningLevel(KAMMSEMCDefaultStereoWideningLevel);
        iMStereoWideningControl->Apply();
    }
    else
    {
        // Disable the effect

        DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl::SetEnabledL(false).");
        iMStereoWideningControl->Disable();
    }

}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::PrepareControlL
// Function which is called after the correct state is set in Player.
// -----------------------------------------------------------------------------
//
void CAMMSEMCAudioVirtualizerControl::PrepareControlL()
{
    // Perform the action only for the first time, skip if called afterwards
    if (!iMStereoWideningControl)
    {
        DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl::PrepareControlL");
        //Create AudioVirtualizer Effect Control
        iStreamControl = (static_cast<CMMAEMCAudioPlayer*>(iMMAPlayer))->StreamControl();
        iFactory = (static_cast<CMMAEMCAudioPlayer*>(iMMAPlayer))->MMFactory();

        MEffectControl* temp(NULL);
        User::LeaveIfError(iFactory->CreateEffectControl(KStereoWideningEffectControl, temp));
        iMStereoWideningControl  = static_cast<MStereoWideningControl*>(temp);
        User::LeaveIfError(iStreamControl->AddEffect(*iMStereoWideningControl));
    }
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::DeallocateControl
// Function which is called after the correct state is set in Player.
// -----------------------------------------------------------------------------
//
void CAMMSEMCAudioVirtualizerControl::DeallocateControl()
{

    if (iMStereoWideningControl)
    {
        DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl::DeallocateControl");

        // StereoWidening for Audio can be disabled or enabled
        TRAPD(err,iMStereoWideningControl->Disable());
        if (err != KErrNone)
        {
            //Some EMC Error
            DEBUG_INT("AMMS::CAMMSEMCAudioVirtualizerControl::DeallocateControl err = %d",err);
        }
        //return the control to factory
        MEffectControl* temp = iMStereoWideningControl;
        iStreamControl->RemoveEffect(*temp);
        // Delete the Effect
        MEffectControl* tempCtrl = iMStereoWideningControl;
        iFactory->DeleteEffectControl(tempCtrl);
        iMStereoWideningControl = NULL;
    }
}

const TDesC& CAMMSEMCAudioVirtualizerControl::ClassName() const
{
    return KAMMSEMCAudioVirtualizerControl;
}


// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::SetEnforcedL
// Enforces the effect to be in use.
// -----------------------------------------------------------------------------
//
void CAMMSEMCAudioVirtualizerControl::SetEnforcedL(TBool aEnforced)
{
    DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl:SetEnforcedL");
    // Indicate the effect is to be enforced or not. ETrue = Enforced.

    iMStereoWideningControl->Enforce(aEnforced);

    ApplySettingsL();

}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::Enforced
// Returns the current enforced setting of the effect.
// -----------------------------------------------------------------------------
//
TBool CAMMSEMCAudioVirtualizerControl::Enforced()
{
    // Returns ETrue if the effect is enforced, EFalse if not enforced.
    TBool enforced;
    iMStereoWideningControl->IsEnforced(enforced);
    return enforced;

}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::SetScopeL
// Sets the scope of the effect.
// -----------------------------------------------------------------------------
//
void CAMMSEMCAudioVirtualizerControl::SetScopeL(TInt aScope)
{
    DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl:SetScopeL");
    __ASSERT_DEBUG(
        (aScope == CAMMSEffectControlGroup::EScopeLiveOnly),
        User::Invariant());
    // Just to suppress warning in release build
    (void)aScope;
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::Scope
// Returns the scope in which the effect is present.
// -----------------------------------------------------------------------------
//
TInt CAMMSEMCAudioVirtualizerControl::Scope()
{
    // For now only the (LIVE_ONLY) scope is supported.
    return CAMMSEffectControlGroup::EScopeLiveOnly;
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::ApplySettingsL
// Apply changed settings if Effect is in enabled state.
// -----------------------------------------------------------------------------
void CAMMSEMCAudioVirtualizerControl::ApplySettingsL()
{
    DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl:ApplySettingsL called, checking state");
    TBool enabled;
    iMStereoWideningControl->IsEnabled(enabled);
    if (enabled)
    {
        DEBUG("AMMS::CAMMSEMCAudioVirtualizerControl:ApplySettingsL calling ApplyL");
        iMStereoWideningControl->Apply();
    }
}


// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
void CAMMSEMCAudioVirtualizerControl::ConstructL()
{
    // Create array for preset names
    iPresetNames = new(ELeave) CDesCArrayFlat(1);

    // Set current preset to a negative value as it is not set yet
    iCurrentPreset = -1;

    CAMMSEffectControl::ConstructL();
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility =
        new(ELeave)CAMMSEMCAudioVirtualizerEnvironmentalPresetUtility;
    iAMMSEMCAudioVirtualizerEnvironmentalPresetUtility->ConstructL();
}

// -----------------------------------------------------------------------------
// CAMMSEMCAudioVirtualizerControl::CAMMSEMCAudioVirtualizerControl
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
CAMMSEMCAudioVirtualizerControl::CAMMSEMCAudioVirtualizerControl(
    CMMAPlayer* aPlayer)
        : CAMMSEffectControl(aPlayer)
{
    iMMAPlayer = aPlayer;
}

//  End of File