/*

* Copyright (c) 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:  Implementation of Wrapper for Audio Player Utility

*

*/

// ===========================================================================  

// includes

#include <mdaaudiosampleplayer.h>

#include <AudioPreference.h>

#include "Cam.hrh"

#include "CamPanic.h"

#include "camlogging.h"

#include "CamUtility.h" // for resource id's of sounds

#include "mcamplayerobserver.h"

#include "camaudioplayerwrapper.h"

#include "CamPerformance.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "camaudioplayerwrapperTraces.h"

#endif

// ===========================================================================  

// Constants

const TReal32 KCamSoundVol = 0.75f; 

// Migrated directly from old sound player.

#ifndef __WINSCW__

  static const TUint KAudioPriority = KAudioPriorityCameraTone;

#else

  static const TUint KAudioPriority = KAudioPriorityVideoRecording;

#endif // __WINSCW__                                                                                              

// ===========================================================================  

// public constructors and destructor

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

// NewL <<static>>

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

//

CCamAudioPlayerWrapper* 

CCamAudioPlayerWrapper::NewL( MCamPlayerObserver& aObserver, 

                              TInt                aSoundId )

  {

  PRINT( _L("Camera => CCamAudioPlayerWrapper::NewL()") );

  CCamAudioPlayerWrapper* self = 

    new (ELeave) CCamAudioPlayerWrapper( aObserver, aSoundId );

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop( self );

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::NewL()") );

  return self;

  }

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

// destructor <<virtual>>

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

//

CCamAudioPlayerWrapper::~CCamAudioPlayerWrapper()

  {

  if( iPlayer )

    {

    iPlayer->Stop();

    iPlayer->Close();

    delete iPlayer;

    iPlayer = NULL;

    }

  }

// ===========================================================================  

// from CCamPlayerWrapperBase

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

// Id <<virtual>><<const>>

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

//

TInt 

CCamAudioPlayerWrapper::Id() const

  {

  return iSoundId;

  }

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

// IsEqualSound <<virtual>><<const>>

//

// Compare if two sounds are equal. 

// If the ids or filenames match, the sounds are considered to be equal.

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

//

TBool

CCamAudioPlayerWrapper::IsEqualSound( TInt aSoundId ) const

  {

  TInt eq( EFalse );

  TRAP_IGNORE( 

    {

    eq = aSoundId == iSoundId

      || MapSoundId2FilenameL( aSoundId ) == MapSoundId2FilenameL( iSoundId );

    });

  return eq;

  }

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

// Play <<virtual>>

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

//

void 

CCamAudioPlayerWrapper::Play( TBool aCallback )

  {

  PRINT2( _L("Camera => CCamAudioPlayerWrapper::Play, callback:%d iState[%s]"), 

          aCallback, 

          KCamAudioPlayerWrapperStateNames[iState] );

  switch( iState )

    {

    case CCamAudioPlayerWrapper::EReady:

      iPlayRequested = EFalse;

      iState         = CCamAudioPlayerWrapper::EPlaying;

      iCallback      = aCallback;

      iPlayer->SetVolume( static_cast<TInt>( iPlayer->MaxVolume()* KCamSoundVol ) );

      iPlayer->Play();

      break;

    case CCamAudioPlayerWrapper::EInitializing:

      iPlayRequested = ETrue;

      iCallback      = aCallback;

      break;

    case CCamAudioPlayerWrapper::ECorrupt:

      // Notify observer rigth away as init has failed.

      iCallback      = aCallback;

      NotifyPlayComplete( KErrCorrupt );

      break;

    case CCamAudioPlayerWrapper::EPlaying:

      PRINT( _L("Camera <> WARNING: Still playing old sound, need to stop early") );

      iPlayer->Stop();

      // Notify observer that playing was interrupted (if callback was requested for previous play).

      // Sets state to idle so that we are ready to play again.

      NotifyPlayComplete( KErrAbort );

      // Now we can repeat the call as the state is right.

      Play( aCallback ); 

      break;

    case CCamAudioPlayerWrapper::EIdle:

    default:

      //Set state and ignore otherwise...

      PRINT( _L("Camera <> CCamAudioPlayerWrapper::Play invalid state") );

      iState = CCamAudioPlayerWrapper::ECorrupt;

      break;

    }

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::Play") );

  }

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

// CancelPlay <<virtual>>

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

//

void 

CCamAudioPlayerWrapper::CancelPlay()

  {

  PRINT1( _L("Camera => CCamAudioPlayerWrapper::CancelPlay, id:%d"), iSoundId );

  switch( iState )

    {

    case CCamAudioPlayerWrapper::EPlaying:

      PRINT( _L("Camera <> CCamAudioPlayerWrapper::CancelPlay .. iState == EPlaying, call Stop()..") );

      iPlayer->Stop();

      NotifyPlayComplete( KErrAbort );

      break;

    default:

      break;  

    }

  // Make sure pending Play() is cancelled.

  iPlayRequested = EFalse;      

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::CancelPlay") );

  }

// ===========================================================================  

// from MMdaAudioPlayerCallback

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

// MapcInitComplete <<virtual>>

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

//

void 

CCamAudioPlayerWrapper

::MapcInitComplete(       TInt                       aStatus, 

                    const TTimeIntervalMicroSeconds& /*aDuration*/ )

  {

  PRINT2( _L("Camera => CCamAudioPlayerWrapper::MapcInitComplete, id:%d status:%d"), iSoundId, aStatus );

  if( KErrNone != aStatus )

    {

    // If we encounter an error in init phase,

    // we'll notify observer once Play gets called.

    iState = CCamAudioPlayerWrapper::ECorrupt;

    }

  else

    {

    iState = CCamAudioPlayerWrapper::EReady;

    }

  // If play has been called before init has finished

  // try to play now. If we had an error in init,

  // Play() will handle this based on iState.

  if( iPlayRequested )

    {

    Play( iCallback );

    }

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::MapcInitComplete") );

  }

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

// MapcPlayComplete <<virtual>>

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

//

void 

CCamAudioPlayerWrapper::MapcPlayComplete( TInt aStatus )

  {

  NotifyPlayComplete( aStatus );

  }

// ===========================================================================  

// other public

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

// MapSoundId2FilenameL <<static>>

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

//

TPtrC

CCamAudioPlayerWrapper::MapSoundId2FilenameL( TInt aSoundId )

  {

  PRINT1( _L("Camera => CCamAudioPlayerWrapper::MapSoundId2FilenameL, id:%d"), aSoundId );

  TPtrC filename( KNullDesC );

  switch( aSoundId )

    {

    case ECamVideoStartSoundId:    filename.Set( KCamVideoStartTone );    break;

    case ECamVideoStopSoundId:     filename.Set( KCamVideoStopTone  );    break;

    case ECamVideoPauseSoundId:    filename.Set( KCamVideoPauseTone );    break;

    case ECamVideoResumeSoundId:   filename.Set( KCamVideoStartTone );    break;

    case ECamAutoFocusFailed:      User::Leave( KErrNotSupported );       break;

    case ECamAutoFocusComplete:    filename.Set( KCamAutoFocusComplete ); break;

    case ECamStillCaptureSoundId1: filename.Set( KCamCaptureTone1 );      break;

    case ECamStillCaptureSoundId2: filename.Set( KCamCaptureTone2 );      break;

    case ECamStillCaptureSoundId3: filename.Set( KCamCaptureTone3 );      break;

    case ECamStillCaptureSoundId4: filename.Set( KCamCaptureTone4 );      break;

    case ECamBurstCaptureSoundId1: filename.Set( KCamBurstCaptureTone1 );      break;

    case ECamBurstCaptureSoundId2: filename.Set( KCamBurstCaptureTone2 );      break;

    case ECamBurstCaptureSoundId3: filename.Set( KCamBurstCaptureTone3 );      break;

    case ECamBurstCaptureSoundId4: filename.Set( KCamBurstCaptureTone4 );      break;

    case ECamSelfTimerSoundId:     filename.Set( KCamSelfTimerTone );      break;

    default:

      __ASSERT_DEBUG( EFalse, CamPanic( ECamPanicNotSupported ) );

      break;

    }

  PRINT1( _L("Camera <= CCamAudioPlayerWrapper::MapSoundId2FilenameL, return [%S]"), &filename );

  return filename;

  }

// ===========================================================================  

// other private

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

// InitL

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

//

void 

CCamAudioPlayerWrapper::InitL()

  {

  PRINT( _L("Camera => CCamAudioPlayerWrapper::InitL") );

  if( CCamAudioPlayerWrapper::EIdle == iState )

    {

    iState = CCamAudioPlayerWrapper::EInitializing;

    // Our process uses multiple players. Ensure they

    // (or their internal controllers) share the same

    // heap so we don't run out of memory chunks.

    iPlayer->UseSharedHeap();

    iPlayer->OpenFileL( MapSoundId2FilenameL( iSoundId ) );

    }

  else

    {

    CamPanic( ECamPanicInvalidState );

    PRINT( _L("Camera <> CCamAudioPlayerWrapper::InitL invalid state") );

    iState = CCamAudioPlayerWrapper::ECorrupt;

    User::Leave(KErrCorrupt);

    }

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::InitL") );

  }

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

// NotifyPlayComplete

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

//

void

CCamAudioPlayerWrapper::NotifyPlayComplete( TInt aStatus )

  {

  PRINT1( _L("Camera => CCamAudioPlayerWrapper::NotifyPlayComplete, status:%d"), aStatus );

  switch( iState ) 

    {

    // Problem initializing.

    // Init is not tried again as it could slow down the capturing.

    case CCamAudioPlayerWrapper::ECorrupt:

      break;

    // Normal case where the playing has completed.

    // Set state to EReady to indicate we are ready 

    // for new play request. 

    case CCamAudioPlayerWrapper::EPlaying:

      iState = CCamAudioPlayerWrapper::EReady;

      break;

    // Other states not allowed here.

    default:

      // Make this player ready that we can play new sound.

      PRINT( _L("Camera <> CCamAudioPlayerWrapper::NotifyPlayComplete invalid state") );

      iState = CCamAudioPlayerWrapper::EReady;

      break;

    }

  // Clear flag just in case.

  iPlayRequested = EFalse;

  OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAUDIOPLAYERWRAPPER_NOTIFYPLAYCOMPLETE, "e_CAM_APP_CAPTURE_SOUND_PLAY 0" ); //CCORAPP_CAPTURE_SOUND_PLAY_END

  // Notify observer with our sound id and received status.

  if( iCallback )

    iObserver.PlayComplete( aStatus, iSoundId );

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::NotifyPlayComplete") );

  }

// ===========================================================================  

// private constructors

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

// ConstructL

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

//

void 

CCamAudioPlayerWrapper::ConstructL()

  {

  PRINT( _L("Camera => CCamAudioPlayerWrapper::ConstructL()") );

  iPlayer = CMdaAudioPlayerUtility::NewL( 

              *this, 

               KAudioPriority ,

               TMdaPriorityPreference( KAudioPrefCamera ) );

  InitL();

  PRINT( _L("Camera <= CCamAudioPlayerWrapper::ConstructL()") );

  }

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

// C++ constructor

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

//

CCamAudioPlayerWrapper

::CCamAudioPlayerWrapper( MCamPlayerObserver& aObserver, 

                          TInt                aSoundId )

  : iObserver     ( aObserver                     ),

    iSoundId      ( aSoundId                      ),

    iPlayer       ( NULL                          ),

    iState        ( CCamAudioPlayerWrapper::EIdle ),

    iPlayRequested( EFalse                        ),

    iCallback     ( EFalse                        )

  {

  }

// ===========================================================================  

// end of file