/*
* Copyright (c) 2004-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:  Handles the tone playing for the VoiceUIRecognition
*
*/


// INCLUDE FILES
#include <aknsoundsystem.h>
#include <aknappui.h>
#include <AccessoryServer.h>        //RAccessoryServer
#include <AccessoryConnection.h>    //RAccessoryConnection

#include <centralrepository.h>

#include <StringLoader.h>
#include <AudioPreference.h>

#include <srsfdomaincrkeys.h>

#include <vuivoicerecognition.rsg>
#include "vuictoneplayer.h"

#include "rubydebug.h"

// CONSTANTS

// Maximum value of the volume setting in Central Repository
const TInt KMaxRepositoryVolume = 10;


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

// ---------------------------------------------------------
// CTonePlayer* CTonePlayer::NewL
// Two-phased constructor.
// ---------------------------------------------------------
//
CTonePlayer* CTonePlayer::NewL()
    {
    CTonePlayer* self = new (ELeave) CTonePlayer;    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
// Destructor
CTonePlayer::~CTonePlayer()
    {
    RUBY_DEBUG0( "CTonePlayer::~CTonePlayer START" );

    if ( iAudioPlayer )
        {
        iAudioPlayer->Close();
        delete iAudioPlayer;
        }

    delete iStartSound;
    delete iConfirmationSound;
    delete iBtStartSound;

    iObserver = NULL;
    
    RUBY_DEBUG0( "CTonePlayer::~CTonePlayer EXIT" );
    }

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

// -----------------------------------------------------------------------------
// CTonePlayer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CTonePlayer::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CTonePlayer::ConstructL" );

    iAudioPlayer = CMdaAudioPlayerUtility::NewL( *this,
                                                 KAudioPriorityVoiceDial, 
                                                 TMdaPriorityPreference( KAudioPrefVoiceStarting ) );

    iVolume = KErrGeneral;
    
    CRepository* client = CRepository::NewLC( KCRUidSRSFSettings );
    client->Get( KSRSFPlaybackVolume, iVolume );
    CleanupStack::PopAndDestroy( client );

    iStartSound = StringLoader::LoadL( R_VOICE_START_SOUND_PATH );
    iConfirmationSound = StringLoader::LoadL( R_VOICE_CONFIRMATION_SOUND_PATH );
    iBtStartSound = StringLoader::LoadL( R_VOICE_BT_START_SOUND_PATH );
    iBTAcc = EFalse;
    
    ChekcAccesoryStatusL();
    }
  
 // ---------------------------------------------------------
// CTonePlayer::RegisterObserver
// Sets the observer
// ---------------------------------------------------------
//  
void CTonePlayer::RegisterObserver( MMdaAudioPlayerCallback* aObserver )
    {
    RUBY_DEBUG0( "CTonePlayer::RegisterObserver START" );
    
    iObserver = aObserver;
    
    RUBY_DEBUG0( "CTonePlayer::RegisterObserver EXIT" );
    }

// ---------------------------------------------------------
// CTonePlayer::InitToneL
// Perform initialization for Playing the appropriate tone
// ---------------------------------------------------------
//
void CTonePlayer::InitToneL( TInt aSid )
   {
    RUBY_DEBUG_BLOCK( "CTonePlayer::PlayToneInitL" );
    
    iAudioPlayer->Stop();
    iAudioPlayer->Close();

    if ( aSid == EAvkonSIDNameDiallerStartTone )
        {
        RUBY_DEBUG0( "CTonePlayer::InitToneL - case: EAvkonSIDNameDiallerStartTone" );
        TInt err = KErrNone;
        if ( iBTAcc )
            {
            TRAP( err, iAudioPlayer->OpenFileL( *iBtStartSound ) );
            }
        else
            {
            TRAP( err, iAudioPlayer->OpenFileL( *iStartSound ) );
            }
        if ( err )
            {
            RUBY_ERROR1( "CTonePlayer::InitToneL - err [%d]", err );
                    
            // Cannot play sound, but observer still needs to be notified
            iObserver->MapcInitComplete( err, 0 );
            }
        }
    else if ( aSid == EAvkonSIDConfirmationTone )
        {
        RUBY_DEBUG0( "CTonePlayer::InitToneL - case: EAvkonSIDConfirmationTone" );

        TRAPD( err, iAudioPlayer->OpenFileL( *iConfirmationSound ) );
        if ( err )
            {
            RUBY_ERROR1( "CTonePlayer::InitToneL - err [%d]", err );
                    
            // Cannot play sound, but observer still needs to be notified
            iObserver->MapcInitComplete( err, 0 );
            }
        }
    }

// ---------------------------------------------------------
// CTonePlayer::PlayTone
// Plays the appropriate tone
// ---------------------------------------------------------
//
void CTonePlayer::PlayTone( TInt aSid )
    {
    RUBY_DEBUG0( "CTonePlayer::PlayTone START" );
    
    switch ( aSid )
        {
        case EAvkonSIDNameDiallerStartTone:
        case EAvkonSIDConfirmationTone:
            {
            iAudioPlayer->SetVolume( ScaledVolume() );
            iAudioPlayer->Play();
            break;
            }
            
        case EAvkonSIDNameDiallerAbortTone:
        case EAvkonSIDNameDiallerErrorTone:
            {
            if ( iAvkonAppUiBase )
                {               
                iAudioPlayer->Stop();
                iAudioPlayer->Close();
                
                iAvkonAppUiBase->KeySounds()->PlaySound( aSid );
                }

            MapcPlayComplete( KErrNone );
            break;
            }
        
        default:
            break;
        }
    
    RUBY_DEBUG0( "CTonePlayer::PlayTone EXIT" );
    }

// ---------------------------------------------------------------------------
// CTonePlayer::MapcInitComplete
// CMdaAudioPlayerUtility initialization complete
// ---------------------------------------------------------------------------
//
void CTonePlayer::MapcInitComplete( TInt aError,
                                    const TTimeIntervalMicroSeconds& aDuration )
    {
    RUBY_DEBUG0( "CTonePlayer::MapcInitComplete START" );

    iObserver->MapcInitComplete( aError, aDuration );
    
    RUBY_DEBUG0( "CTonePlayer::MapcInitComplete EXIT" );
    }

// ---------------------------------------------------------------------------
// CTonePlayer::MapcPlayComplete
// Playback complete, notify observer
// ---------------------------------------------------------------------------
//
void CTonePlayer::MapcPlayComplete( TInt aError )
    {
    RUBY_DEBUG0( "CTonePlayer::MapcPlayComplete START" );

    iAudioPlayer->Stop();
    iAudioPlayer->Close();
    iObserver->MapcPlayComplete( aError );

    RUBY_DEBUG0( "CTonePlayer::MapcPlayComplete EXIT" );
    }

// ---------------------------------------------------------------------------
// CTonePlayer::ScaledVolume
// ---------------------------------------------------------------------------
//    
TInt CTonePlayer::ScaledVolume()
    {
    TInt volume = iAudioPlayer->MaxVolume();
    if ( iVolume >= 0 )
        {
        // Scale value
        volume = ( iVolume * volume ) / KMaxRepositoryVolume;
        }
        
    return volume;
    }

// ---------------------------------------------------------
// CTonePlayer::ChekcAccesoryStatus
// ---------------------------------------------------------
//  
void CTonePlayer::ChekcAccesoryStatusL()
    {    
    // Connection to the accessory server
    RAccessoryServer accessoryServer;    
    // Subsession for server
    RAccessoryConnection accessoryConnection;    
    //Generic ID array for accessories
    TAccPolGenericIDArray accessoryArray;
    
    TInt err = KErrNone;
    //connect to accessory server
    err = accessoryServer.Connect();
    if ( err == KErrNone )
        {
        //create subsession to accessory server
        err = accessoryConnection.CreateSubSession( accessoryServer );
        if ( err == KErrNone )
            {
            accessoryConnection.GetAccessoryConnectionStatus( accessoryArray );
            
            TAccPolGenericID genId;
            for ( TInt i = 0; i < accessoryArray.Count(); i++ )
                {
                genId = accessoryArray.GetGenericIDL( i );

                if ( genId.PhysicalConnectionCaps( KPCBluetooth ) && 
                    ( genId.DeviceTypeCaps( KDTHeadset ) || genId.DeviceTypeCaps( KDTCarKit ) ) )
                    {
                    iBTAcc = ETrue;
                    }
                }
            }
        }

    accessoryConnection.CloseSubSession();
    accessoryServer.Close();
    }

//  End of File