/*

* Copyright (c) 2002-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:  Audio player implementation.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <eikenv.h>

#include <apgcli.h>

#include <apmrec.h>

#include <AudioPreference.h>

#include <utf.h>    // For converting data for TTS

#include <c3dringingtoneinterface.h>

#include <AudioOutput.h>

#include "cphoneaudioplayer.h"

#include "cphoneringingtone.h"

#include "mphoneaudioplayerobserver.h"

#include "phoneconstants.h"

#include "phoneui.pan"

// CONSTANTS

_LIT( KFileListRngMimeType, "application/vnd.nokia.ringing-tone" );

//Min volume level

const TInt KMinVolumeLevel = 1;

//Max volume level

const TInt KMaxVolumeLevel = 10;

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

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

// CPhoneAudioPlayer::CPhoneAudioPlayer

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

//

CPhoneAudioPlayer::CPhoneAudioPlayer( TAudioDataFormat aDataFormat,

    MPhoneAudioPlayerObserver& aObserver, 

    TInt aPriority, 

    TUint aPreference,

    TInt aId )

    : iFormat( aDataFormat ),

    iObserver( aObserver ),

    iPriority( aPriority ),

    iPreference( aPreference ),

    iId( aId )

    {

    }

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

// CPhoneAudioPlayer::ConstructL

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

//

void CPhoneAudioPlayer::ConstructL(

    const TDesC& aFileName,

    CMdaServer* aMdaServer )

    {

    if ( iFormat == EFormatTone )

        {

        iTonePlayer = CMdaAudioToneUtility::NewL( *this, aMdaServer );

        iTonePlayer->PrepareToPlayFileSequence( aFileName );

        iPlayerStatus = EToneLoading;

        }

    else

        {

        //audio sample player

            "CPhoneAudioPlayer::ConstructL - aFileName(%S), iPriority(%d), iPreference(%d)",

            &aFileName, 

            iPriority, 

            iPreference );

        iSamplePlayer = CMdaAudioPlayerUtility::NewFilePlayerL( 

            aFileName,

            *this, 

            iPriority,

            static_cast< TMdaPriorityPreference >( iPreference ),

        iPlayerStatus = EToneLoading;

        }

    }

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

// CPhoneAudioPlayer::ConstructSeqL

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

//

void CPhoneAudioPlayer::ConstructSeqL( 

    const TDesC8& aSequence,

        CMdaServer* aMdaServer )

    {

    iTonePlayer = CMdaAudioToneUtility::NewL( *this, aMdaServer );

    iSequence = aSequence.AllocL();

    iTonePlayer->PrepareToPlayDesSequence( *iSequence );

    iPlayerStatus = EToneLoading;

    }

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

// CPhoneAudioPlayer::ConstructTtsL

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

//

void CPhoneAudioPlayer::ConstructTtsL( 

    const TDesC& aTtsText, 

    TInt aPriority,

    TUint aPreference )

    {

    delete iTtsPlayer; // if any

    iTtsPlayer = NULL;

    iTtsPlayer = 

        CMdaAudioPlayerUtility::NewL( 

            *this, aPriority, 

            static_cast< TMdaPriorityPreference >( aPreference ) );

    delete iTtsText;  // if any

    iTtsText = NULL;

    // UTF-8 strings can take up to 4 bytes per character

    iTtsText = HBufC8::NewL( aTtsText.Length() << KTimesToMultiply ); 

    TPtr8 refText = iTtsText->Des(); 

    User::LeaveIfError( 

        CnvUtfConverter::ConvertFromUnicodeToUtf8( refText, aTtsText ) );

    // UTF-8 chars can be up to 4 bytes long, but usually 

    // take 1-2 bytes, 3 for asian chars.

    HBufC8* oldText = iTtsText;

    iTtsText = iTtsText->ReAlloc( iTtsText->Length() );

    if ( !iTtsText )

        {

        // ReAlloc failed, set back to original.

        iTtsText = oldText;

        }

    iTtsPlayer->OpenDesL( *iTtsText );

    }

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

// CPhoneAudioPlayer::New

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

//

CPhoneAudioPlayer* CPhoneAudioPlayer::New( 

    const CPhoneRingingTone& aRingingTone, 

    TInt aPriority, 

    TUint aPreference,

    MPhoneAudioPlayerObserver& aObserver, 

    TInt aId,

    CMdaServer* aMdaServer,

    TBool aExtSecNeeded )

    {

    CPhoneAudioPlayer* self = NULL;

    TRAPD( err, self = CPhoneAudioPlayer::NewL( 

        aRingingTone,

        aPriority,

        aPreference,

        aObserver,

        aId,

        aMdaServer,

        aExtSecNeeded ) );

    if ( err != KErrNone )

        {

        return NULL;

        }

    return self;

    }

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

// CPhoneAudioPlayer::NewL

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

//

CPhoneAudioPlayer* CPhoneAudioPlayer::NewL( 

    const CPhoneRingingTone& aRingingTone, 

    TInt aPriority,

    TUint aPreference,

    MPhoneAudioPlayerObserver& aObserver,

    TInt aId,

    CMdaServer* aMdaServer,

    TBool aExtSecNeeded )

    {

        aExtSecNeeded );

    // Check the file DRM property if extend secure is needed.

    if ( aExtSecNeeded )

        {

        if ( !aRingingTone.IsFileInRom() &&

             !aRingingTone.IsFileDrmProtected() )

            {

            User::Leave( KErrPermissionDenied );

            }

        }

    TAudioDataFormat format = 

    ( aRingingTone.MimeType().CompareF( KFileListRngMimeType ) == KErrNone ) 

    ? EFormatTone :EFormatSample;

    CPhoneAudioPlayer* self = 

        new (ELeave) CPhoneAudioPlayer( 

            format,

            aObserver, 

            aPriority,

            aPreference,

            aId );

    CleanupStack::PushL( self );

    self->ConstructL( aRingingTone.FileName(), aMdaServer );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneAudioPlayer::NewL

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

//

CPhoneAudioPlayer* CPhoneAudioPlayer::NewL( 

    const TDesC& aFileName, 

    TInt aPriority,

    TUint aPreference,

    MPhoneAudioPlayerObserver& aObserver,

    TInt aId,

    CMdaServer* aMdaServer,

    TBool aExtSecNeeded )

    {

    CPhoneRingingTone* tone = CPhoneRingingTone::NewL( aFileName );

    CleanupStack::PushL( tone );

    CPhoneAudioPlayer* player = CPhoneAudioPlayer::NewL( *tone,

                                                         aPriority,

                                                         aPreference,

                                                         aObserver,

                                                         aId,

                                                         aMdaServer,

                                                         aExtSecNeeded );

    CleanupStack::PopAndDestroy( tone );

    }

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

// CPhoneAudioPlayer::NewSeqL

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

//

CPhoneAudioPlayer* CPhoneAudioPlayer::NewSeqL(

    const TDesC8& aSequence,

    TInt aPriority,

    TUint aPreference,

    MPhoneAudioPlayerObserver& aObserver, 

    TInt aId,

    CMdaServer* aMdaServer )

    {

    CPhoneAudioPlayer* self = 

        new (ELeave) CPhoneAudioPlayer( 

            EFormatTone, 

            aObserver, 

            aPriority,

            aPreference,

            aId );

    CleanupStack::PushL( self );

    self->ConstructSeqL( aSequence, aMdaServer  );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneAudioPlayer::NewTtsL

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

//

CPhoneAudioPlayer* CPhoneAudioPlayer::NewTtsL(

    const TDesC& aText,

    TInt aPriority,

    TUint aPreference,

    MPhoneAudioPlayerObserver& aObserver, 

    TInt aId )

    {

    CPhoneAudioPlayer* self = 

        new (ELeave) CPhoneAudioPlayer( 

            EFormatTts, 

            aObserver, 

            aPriority,

            aPreference,

            aId );

    CleanupStack::PushL( self );

    self->ConstructTtsL( aText, aPriority, aPreference );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneAudioPlayer::~CPhoneAudioPlayer

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

//

CPhoneAudioPlayer::~CPhoneAudioPlayer()

    {

    if ( iAudioOutput )

        {

        {

        } 

    if ( i3DPlugin )

       {

        i3DPlugin->Stop();

        delete i3DPlugin;

        }

    // ECom cleanup

    REComSession::FinalClose();

        {

        delete iSamplePlayer; 

        }

    if ( iTtsPlayer )

        {

        }

    if ( iSequence )

        {

        delete iSequence; 

        }

        {

        delete iTtsText;

    }

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

// CPhoneAudioPlayer::Play

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

//

void CPhoneAudioPlayer::Play( TRingingType aRingType, TInt aVolume, TInt aTTsToBePlayed )

    {

        "CPhoneAudioPlayer::Play - iFormat(%d), iPlayerStatus(%d)",

        iFormat, 

        iPlayerStatus );

        "CPhoneAudioPlayer::Play - aRingType(%d), aVolume(%d), aTTsToBePlayed(%d)",

        aRingType, 

        aVolume,

        aTTsToBePlayed );

    iRingType = aRingType;

    iVolume = aVolume;

    iTTsToBePlayed = aTTsToBePlayed;

    if ( iFormat == EFormatTone )

        {

        switch ( iPlayerStatus )

            {

            case ETonePlaying:

                iTonePlayer->CancelPlay();

                DoPlay();

                break;

            case EToneReady:

                iPlayerStatus = ETonePlaying;

                DoPlay();

                break;

            case EToneLoading:

                iToBePlaying = ETrue;

                break;

            default:

                __ASSERT_DEBUG( EFalse, 

            }

        }

    else if ( iFormat == EFormatTts )

        {

        switch ( iPlayerStatus )

            {

            case ETonePlaying:

                //stop previous playing

                iTtsPlayer->Stop();

                DoPlay();

                break;

            case EToneReady:

                iPlayerStatus = ETonePlaying;

                DoPlay();

                break;

            case EToneLoading:

                iToBePlaying = ETrue;

                break;

            default:

                __ASSERT_DEBUG( EFalse, 

                        Panic( EPhoneViewCaseNotHandled ) );

            }

        }

    else

        {

        switch ( iPlayerStatus )

            {

            case ETonePlaying:

                //stop previous playing

                StopPlaying();

                iPlayerStatus = ETonePlaying;

                DoPlay();

                break;

            case EToneReady:

                iPlayerStatus = ETonePlaying;

                DoPlay();

                break;

            case EToneLoading:

                iToBePlaying = ETrue;

                break;

            default:

                __ASSERT_DEBUG( EFalse, 

                        Panic( EPhoneViewCaseNotHandled ) );

            }

        }

    }

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

// CPhoneAudioPlayer::ReStartPlaying

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

void CPhoneAudioPlayer::ReStartPlaying()

    {

        "CPhoneAudioPlayer::ReStartPlaying - iFormat(%d), iRingType(%d), iVolume(%d)",

        iFormat, 

        iRingType, 

        iVolume );

    if ( iFormat == EFormatTone )

        {

        iTonePlayer->Play();

        iPlayerStatus = ETonePlaying;

        }

    else if ( iFormat == EFormatTts )

        {

        iTtsPlayer->Play();

        iPlayerStatus = ETonePlaying;

    else

        {

        iSamplePlayer->Play();

        iPlayerStatus = ETonePlaying;

    }

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

// CPhoneAudioPlayer::StopPlaying

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

//

void CPhoneAudioPlayer::StopPlaying()

    {

    iToBePlaying = EFalse;

    if ( iFormat == EFormatTone )

        {

        if ( EMdaAudioToneUtilityPrepared == iTonePlayer->State() )

            {

            iTonePlayer->CancelPrepare();

            }

        else if ( EMdaAudioToneUtilityPlaying == iTonePlayer->State() )

            {

            iTonePlayer->CancelPlay();

            }

        }

    else if ( iFormat == EFormatTts )

        {

        iTtsPlayer->Stop();

        }

    else

        {

        if ( i3DPlugin )

            {

            i3DPlugin->Stop();

            delete i3DPlugin;