/*
* Copyright (c) 2006 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:  Helper class for managing equalizer utility instances
*                (stub version).
*
*/



// INCLUDE FILES
#include <mpxplaybackmessage.h>
#include <mpxmessagegeneraldefs.h>
#include "mpxequalizerhelper.h"
#include "mpxlog.h"

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

// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CMPXEqualizerHelper::CMPXEqualizerHelper()
    {
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::ConstructL()
    {
    MPX_FUNC("CMPXEqualizerHelper::ConstructL");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CMPXEqualizerHelper* CMPXEqualizerHelper::NewL()
    {
    MPX_FUNC("CMPXEqualizerHelper::NewL");
    CMPXEqualizerHelper* self =
        new ( ELeave ) CMPXEqualizerHelper();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CMPXEqualizerHelper::~CMPXEqualizerHelper()
    {
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Initialize audio equalizer utility for current active playing track.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::InitializeEqualizerUtilityL()
    {
    MPX_FUNC("CMPXEqualizerHelper::InitializeEqualizerUtilityL");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Release audio equalizer utility.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::ReleaseEqualizerUtility()
    {
    MPX_FUNC("CMPXEqualizerHelper::ReleaseEqualizerUtility");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Get current preset ID.
// ---------------------------------------------------------------------------
//
TInt CMPXEqualizerHelper::GetPresetId( TInt& /* aPresetId */ )
    {
    MPX_FUNC("CMPXEqualizerHelper::GetPresetId");
    return KErrNotFound;
    }

// ---------------------------------------------------------------------------
// Initialize secondary audio equalizer utility for situations when the
// engine cannot provide one.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::InitializeBackupEqualizerUtilityL()
    {
    MPX_FUNC("CMPXEqualizerHelper::InitializeBackupEqualizerUtilityL");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Create secondary audio equalizer utility based on latest preset settings.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::CreateBackupEqualizerUtility()
    {
    MPX_FUNC("CMPXEqualizerHelper::CreateBackupEqualizerUtility");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Setup active equalizer utility for equalizer dialog.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::SetupActiveEqualizerUtility()
    {
    MPX_FUNC("CMPXEqualizerHelper::SetupActiveEqualizerUtility");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Launch equalizer dialog.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::DoLaunchEqualizerDialogL()
    {
    MPX_FUNC("CMPXEqualizerHelper::DoLaunchEqualizerDialogL");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Handle playback message.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::DoHandlePlaybackMessageL(
    const CMPXMessage& aMessage )
    {
    MPX_FUNC("CMPXEqualizerHelper::DoHandlePlaybackMessageL");
    TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );
    if ( KMPXMessageGeneral == id )
        {
        switch ( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) )
            {
            case TMPXPlaybackMessage::EStateChanged:
                {
                TMPXPlaybackState state(
                    static_cast<TMPXPlaybackState>(
                        aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) ) );
                DoHandleStateChangedL( state );
                break;
                }
            default:
                {
                // pass
                break;
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// Handle playback state changed.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::DoHandleStateChangedL(
    TMPXPlaybackState /* aState */ )
    {
    MPX_FUNC("CMPXEqualizerHelper::DoHandleStateChangedL");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// From CMPXEqualizerView
// Launch equalizer dialog.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::LaunchEqualizerL()
    {
    MPX_FUNC("CMPXEqualizerHelper::LaunchEqualizerL");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// From MMPXPlaybackObserver
// Handle playback message.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::HandlePlaybackMessage(
    CMPXMessage* aMessage, TInt aError )
    {
    MPX_FUNC("CMPXEqualizerHelper::HandlePlaybackMessage");
    if ( aError == KErrNone && aMessage )
        {
        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );
        }
    }

// ---------------------------------------------------------------------------
// From MEqualizerPresetActivationObserver
// Handle preset id activation from Equalizer dialog.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::HandlePresetActivation(
    TInt /* aActivatedPreset */ )
    {
    MPX_FUNC("CMPXEqualizerHelper::HandlePresetActivation");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// From MMdaAudioPlayerCallback
// Callback when an attempt to open and initialise an audio sample
// has completed.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::MapcInitComplete(
    TInt /* aError */,
    const TTimeIntervalMicroSeconds& /* aDuration */ )
    {
    MPX_FUNC("CMPXEqualizerHelper::MapcInitComplete");
    // Do nothing
    }

// ---------------------------------------------------------------------------
// From MMdaAudioPlayerCallback
// Callback when an attempt to playback an audio sample has completed.
// ---------------------------------------------------------------------------
//
void CMPXEqualizerHelper::MapcPlayComplete(
    TInt /* aError */ )
    {
    MPX_FUNC("CMPXEqualizerHelper::MapcPlayComplete");
    // Do nothing
    }

//  End of File