/*

* Copyright (c) 2005 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:  Plug-In that implements C3DRingingToneInterface.

*

*/

// INCLUDE FILES

#include "CRingingTone3DPlugin.h"

#include "tdaudioconstants.h"

#include "RingingTone3DPluginDebug.h"

#include <EnvironmentalReverbUtility.h>       // CEnvironmentalReverbUtility

#include <SourceDopplerBase.h>                // CSourceDoppler

#include <SourceLocationBase.h>               // CSourceLocation

#include <ListenerLocationBase.h>             // CListenerLocation

#ifndef SPP_NSS_3D_RINGING_TONE_STW_DISABLED

#include <StereoWideningBase.h>               // CStereoWidening

#endif

#include <MProfileEngine.h>

#include <MProfile.h>

#include <MProfileTones.h>

#include <MProfileExtraSettings.h>

#include <MProfile3DToneSettings.h>

#include <MProfileName.h>

#include <ProfileInternal.hrh> // for TProfile3DToneEffect and TProfile3DToneEcho

// CONSTANTS

const TUint32 KDopplerFactor = 100;

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

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

// CRingingTone3DPlugin::NewL

// Two-phased constructor.

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

//

CRingingTone3DPlugin* CRingingTone3DPlugin::NewL( TAny* aParameter )

    {

    // aParameter comes from REComSession::CreateImplementationL

    // (TAny *aConstructionParameters)

    CRingingTone3DPlugin* self = new ( ELeave ) CRingingTone3DPlugin();

    CleanupStack::PushL( self );

    self->ConstructL( aParameter );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CRingingTone3DPlugin::~CRingingTone3DPlugin()

    {

    // Stop() may leave because of CDrmPlayerUtility error

    // (CMMFDrmAudioPlayerUtility::IsValidCustomCommandDestination

    // uses CleanupClosePushL).

    TRAP_IGNORE( Stop() );

    delete iTimer;

    delete iParser;

    }

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

// CRingingTone3DPlugin::Stop

// Stop the playback.

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

//

void CRingingTone3DPlugin::Stop()

    {

    FLOG( _L("CRingingTone3DPlugin::Stop START") );

    // Stop the playback and timer.

    if ( iTimer )

        {

        iTimer->Cancel();    

        }

    StopRingingTone();

    delete iReverbEffect;

    iReverbEffect = NULL;

    delete iDopplerEffect;

    iDopplerEffect = NULL;

    delete iListener;

    iListener = NULL;

    delete iSource;

    iSource = NULL;

#ifdef __STEREO_WIDENING_EFFECT_UI     

    delete iStereoWidening;

    iStereoWidening = NULL;

#endif    

    FLOG( _L("CRingingTone3DPlugin::Stop END") );

    }

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

// CRingingTone3DPlugin::CRingingTone3DPlugin

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

// might leave.

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

//

CRingingTone3DPlugin::CRingingTone3DPlugin()

    {

    iPlaying = EFalse;

    iPlayerType = KErrNotFound;

    iProfileId = KErrNotFound;

    iProfile3DToneEffect = KErrNotFound;

    iProfile3DToneEcho = KErrNotFound;

    iRingingTone = KNullDesC;

    }

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

// CRingingTone3DPlugin::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRingingTone3DPlugin::ConstructL( TAny* aParameter )

    {

    FLOG( _L("CRingingTone3DPlugin::ConstructL START") );

    iTimer = C3DAudioTimeOutTimer::NewL( EPriorityHigh, this );

    iParser = C3DAudioXMLParser::NewL();

    FLOG( _L("CRingingTone3DPlugin::ConstructL END") ); 

    }

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

// CRingingTone3DPlugin::Init

// 

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

//

void CRingingTone3DPlugin::Init( CMdaAudioPlayerUtility* aSamplePlayer )

    {

    FLOG( _L("CRingingTone3DPlugin::InitL START") );

    __ASSERT_ALWAYS( aSamplePlayer, Panic(KErrArgument) );

    iAudioPlayerUtility = aSamplePlayer;

    iPlayerType = EMdaAudioPlayerUtility;

#ifdef _DEBUG			                

    FlogPlayer( iPlayerType );

#endif        

    FLOG( _L("CRingingTone3DPlugin::InitL END") );

    }

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

// CRingingTone3DPlugin::Init

// 

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

//

void CRingingTone3DPlugin::Init( CMdaAudioToneUtility* aSamplePlayer )

    {

    FLOG( _L("CRingingTone3DPlugin::InitL START") );

    __ASSERT_ALWAYS( aSamplePlayer, Panic(KErrArgument) );

    iAudioToneUtility = aSamplePlayer;

    iPlayerType = EMdaAudioToneUtility;

#ifdef _DEBUG			                

    FlogPlayer( iPlayerType );

#endif        

    FLOG( _L("CRingingTone3DPlugin::InitL END") );

    }

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

// CRingingTone3DPlugin::Init

// 

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

//

void CRingingTone3DPlugin::Init( CDrmPlayerUtility* aSamplePlayer )

    {

    //FLOG( _L("CRingingTone3DPlugin::InitL START") );

    __ASSERT_ALWAYS( aSamplePlayer, Panic(KErrArgument) );

    iDrmPlayerUtility = aSamplePlayer;

    iPlayerType = EDrmPlayerUtility;

#ifdef _DEBUG			                

    FlogPlayer( iPlayerType );

#endif        

    //FLOG( _L("CRingingTone3DPlugin::InitL END") );

    }

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

// CRingingTone3DPlugin::Init

// 

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

//

void CRingingTone3DPlugin::Init( CVideoPlayerUtility* aSamplePlayer )

    {

    FLOG( _L("CRingingTone3DPlugin::InitL START") );

    __ASSERT_ALWAYS( aSamplePlayer, Panic(KErrArgument) );

    iVideoPlayerUtility = aSamplePlayer;

    iPlayerType = EVideoPlayerUtility;

#ifdef _DEBUG			                

    FlogPlayer( iPlayerType );

#endif        

    FLOG( _L("CRingingTone3DPlugin::InitL END") );

    }

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

// CRingingTone3DPlugin::SetAttr (from C3DRingingToneInterface.h)

// 

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

//

TInt CRingingTone3DPlugin::SetAttr( T3DRingingToneInterfaceAttr aAttributeKey,

                                    TInt aValue )

    {

    switch (aAttributeKey)

        {

        case E3DRTIAttrProfileId:

            {

            iProfileId = aValue;

            break;

            }

        case E3DRTIAttr3DEffect:

            {

            iProfile3DToneEffect = aValue;

            break;

            }

        case E3DRTIAttr3DEcho:

            {

            iProfile3DToneEcho = aValue;

            break;

            }

        default:

            {

            break;

            }

        }

    return KErrNone;

    }

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

// CRingingTone3DPlugin::SetAttr  (from C3DRingingToneInterface.h)

// 

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

//

TInt CRingingTone3DPlugin::SetAttr( T3DRingingToneInterfaceAttr aAttributeKey,

                                    const TDesC& aValue )

    {

    switch (aAttributeKey)

        {

        case E3DRTIAttr3DRingingTone:

            {

            if ( aValue.Length() < iRingingTone.MaxLength() )

                {

                iRingingTone = aValue;    

                }

            break;

            }

        default:

            {

            break;

            }

        }

    return KErrNone;

    }

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

// CRingingTone3DPlugin::SetAttr  (from C3DRingingToneInterface.h)

// 

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

//

TInt CRingingTone3DPlugin::SetAttr( TInt aAttributeKey, TAny* aValue )

    {

    switch (aAttributeKey)

        {

        case E3DRTIAttrAudioPlayerUtility:

            {

            Init( ( CMdaAudioPlayerUtility* )aValue );

            break;

            }

        case E3DRTIAttrAudioToneUtility:

            {

            Init( ( CMdaAudioToneUtility* )aValue );

            break;

            }

        case E3DRTIAttrDrmPlayerUtility:

            {

            Init( ( CDrmPlayerUtility* )aValue );

            break;

            }

        case E3DRTIAttrVideoPlayerUtility:

            {

            Init( ( CVideoPlayerUtility* )aValue );

            break;

            }

        default:

            {

            break;

            }

        }

    return KErrNone;    

    }

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

// CRingingTone3DPlugin::PlayL

// Start the playback, initialize first in case there has been changes.

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

//

void CRingingTone3DPlugin::PlayL()

    {

    TInt err = KErrNone;

    TRAP( err, DoPlayL() );

    if ( err != KErrNone )

        {

        // 3D play failed - play normal ringing tone

        UnInitialize();

        PlayRingingTone();

        }

    }

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

// CRingingTone3DPlugin::DoPlayL

//

// Start the playback, initialize first in case there has been changes.

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

//

void CRingingTone3DPlugin::DoPlayL()

    {

    FLOG( _L("CRingingTone3DPlugin::DoPlayL START") );

    __ASSERT_ALWAYS( iPlayerType != KErrNotFound, Panic(KErrNotReady) );

    TInt err = KErrNone;

    if ( iTimer )

        {

        iTimer->Cancel();    

        }

    else

        {

        User::Leave( KErrNoMemory );  // ConstructL has failed

        }

    TRAP( err, InitializeL() );  // Initialize the plug-in

    if ( err != KErrNone )

        {

        FLOG( _L("### CRingingTone3DPlugin::InitializeL failed (%d) ###"), err);

        User::Leave(err);

        }

    if ( iProfile3DToneEffect == EProfile3DEffectOff )

        {

        PlayRingingTone();  // play normal ringing tone

        FLOG( _L("CRingingTone3DPlugin::DoPlayL END") );

        return;

        }

#ifdef __STEREO_WIDENING_EFFECT_UI

    if ( iStereoWidening )

        {

        if ( !iStereoWidening->IsEnabled() )

            {

            FLOG( _L("### CStereoWidening not enabled ###") );

            TRAP( err, iStereoWidening->EnableL() );

            if ( err != KErrNone )

                {

                FLOG( _L("### CStereoWidening::EnableL failed (%d) ###"), err);

                User::Leave( err );    

                }

            }

        // play normal ringing tone with stereowidening

        PlayRingingTone();  

        FLOG( _L("CRingingTone3DPlugin::DoPlayL END") );

        return;

        }

#endif

    iCurrentUpdate = KErrNotFound;

    SetNext3DPatternPositionL();

    PlayRingingTone();  // Start playing 3D ringing tone.

    FLOG( _L("CRingingTone3DPlugin::DoPlayL END") );      

    }

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

// CRingingTone3DPlugin::TimerExpiredL

// Callback method for timer expiration.

// Used to update the location and doppler-effects.

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

//

void CRingingTone3DPlugin::TimerExpiredL()

    {

    //FLOG( _L("CRingingTone3DPlugin::TimerExpiredL START") );

    if ( iCurrentUpdate % 10 == 0 )

        {

        FLOG( _L("CRingingTone3DPlugin::TimerExpiredL called (count = %d)"), iCurrentUpdate);

        }

    SetNext3DPatternPositionL();

    //FLOG( _L("CRingingTone3DPlugin::TimerExpiredL END") );

    }

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

// CRingingTone3DPlugin::SetNext3DPatternPositionL

//

// Used to update the location and doppler-effects.

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

//

void CRingingTone3DPlugin::SetNext3DPatternPositionL()

    {

    //FLOG( _L("CRingingTone3DPlugin::SetNext3DPatternPositionL START") );

    TInt err = KErrNone;

    if ( !iSource || !iListener )

        {

        FLOG( _L("### CSourceLocation or CListenerLocation or C3DAudioPattern is NULL ###") );

        User::Leave( KErrDied );

        }

    if ( iCurrentUpdate == KErrNotFound )

        {

        iCurrentUpdate = 0;  // first position

        }

    else

        {

        iCurrentUpdate++;  // next position

        }

    // iCurrentUpdate out of bounds. Start from the beginning.

    if ( iCurrentUpdate >= iParser->CountL() )

        {

        iCurrentUpdate = 0;

        }

    //

    // update doppler-effect

    //

    if ( iDoppler  && iDopplerEffect )

        {

        // Current doppler-velocity.

        T3DVelocity velocity = iParser->VelocityL( iCurrentUpdate );

        // Update the velocity and apply.

        TRAP( err, iDopplerEffect->SetCartesianVelocityL( ( TInt32& )velocity.iXVector, 

                                                          ( TInt32& )velocity.iYVector, 

                                                          ( TInt32& )velocity.iZVector ) );

        if ( err != KErrNone )

            {

            FLOG( _L("### CSourceDoppler::SetCartesianVelocityL failed (%d) ###"), err);

            User::Leave( err );

            }                                                            

        if ( !iDopplerEffect->IsEnabled() )

            {

            FLOG( _L("### CSourceDoppler not enabled ###") );

            TRAP( err, iDopplerEffect->EnableL() );

            if ( err != KErrNone )

                {

                FLOG( _L("### CSourceDoppler::EnableL failed (%d) ###"), err);

                User::Leave( err );

                }

            }

        TRAP( err, iDopplerEffect->ApplyL() );

        if ( err != KErrNone )