/*

* Copyright (c) 2003-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:  This class gives interface to play IM message alert

 *

*/

// INCLUDE FILES

#include    "CCAAudioManager.h"

#include    "chatdefinitions.h"

#include    "ChatDebugPrint.h"

#include    "MCAAudioManagerObserver.h"

#include    "MCANotifierInterface.h"

#include    "CANotifierFactory.h"

#include    "imnginternalcrkeys.h"

#include    "imprivatecrkeys.h"

#include    <MProfileEngine.h>

#include	<pathinfo.h>

#include    <mda/common/resource.h>

#include    <audiopreference.h>

#include    <bautils.h>

#include    <hwrmvibrasdkcrkeys.h>

#include    <coreapplicationuisdomainpskeys.h>

#include    <ProfileEngineSDKCRKeys.h>

#include    <MProfileTones.h>

#include    <TProfileToneSettings.h>

#include    <MProfile.h>

#include    <HWRMVibra.h>

#include <cimpspresenceconnectionuing.h>

#include <CIMPSSAPSettingsStore.h>

#include <CIMPSSAPSettings.h>

#include <CIMPSSAPSettingsList.h>

#include <CPEngNWSessionSlotID2.h>

// CONSTANTS

const TInt KMinVolumeLevel( 1 );

const TInt KMaxVolumeLevel( 10 );

const TInt KAscendingVolumeInterval( 3000000 ); // 3 seconds

const TInt KToneInterval( 1000000 ); // 1 second pause between tones

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

_LIT( KBeepOnceSound, "beep.rng" );

_LIT( KProfileSilentTone, "No_Sound.wav" ); // see CCAToneSettingItem.cpp

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

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

// CCAAudioManager::CCAAudioManager

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

// might leave.

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

//

CCAAudioManager::CCAAudioManager( CIMPSPresenceConnectionUi& aConnUi,

                                  TBool aIMLauncherInvoked )

        :   iAudioPlayerStatus( EAudioPlayerNotCreated ),

        iTonePlayerStatus( EAudioPlayerNotCreated ),

        iIsPlayingDefaultIMSound( EFalse ),

        iIMLauncherInvoked( aIMLauncherInvoked ),

        iConnUI( aConnUi )

    {

    }

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

// CCAAudioManager::ConstructL

// (other items were commented in a header).

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

//

void CCAAudioManager::ConstructL()

    {

    CHAT_DP_FUNC_ENTER( "ConstructL" );

    iProfileApi = CreateProfileEngineL();

    iSapSettings = CIMPSSAPSettingsStore::NewL();

    User::LeaveIfError( iFs.Connect() );

    iCenRep = CRepository::NewL( KCRUidIM );

    CHAT_DP_TXT( "CMdaAudioPlayerUtility::NewL()" );

    iAudioPlayer = CMdaAudioPlayerUtility::NewL( *this );

    iAudioPlayerStatus = EAudioPlayerReady;

    CHAT_DP_TXT( "CMdaAudioToneUtility::NewL()" );

    iTonePlayer = CMdaAudioToneUtility::NewL( *this );

    iTonePlayerStatus = EAudioPlayerReady;

    iProfilesRepository = CRepository::NewL( KCRUidProfileEngine );

    iVibraRepository = CRepository::NewL( KCRUidVibraCtrl );

    // Get initial settings from active profile

    iRingingVolumeNotifyHandler = CCenRepNotifyHandler::NewL( *this,

                                                              *iProfilesRepository,

                                                              CCenRepNotifyHandler::EIntKey,

                                                              KProEngActiveRingingVolume );

    iRingingVolumeNotifyHandler->StartListeningL();

    iRingingTypeNotifyHandler = CCenRepNotifyHandler::NewL( *this,

                                                            *iProfilesRepository,

                                                            CCenRepNotifyHandler::EIntKey,

                                                            KProEngActiveRingingType );

    iRingingTypeNotifyHandler->StartListeningL();

    iVibraNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iVibraRepository,

                                                      CCenRepNotifyHandler::EIntKey,

                                                      KVibraCtrlProfileVibraEnabled );

    iVibraNotifyHandler->StartListeningL();

    User::LeaveIfError( iProfilesRepository->Get( KProEngActiveRingingVolume,

                                                  iRingingVolume ) );

    User::LeaveIfError( iVibraRepository->Get( KVibraCtrlProfileVibraEnabled,

                                               iVibra ) );

    User::LeaveIfError( iApaSession.Connect() );

    // register for changes in message Tone quitting

    iNotifierAPI = CANotifierFactory::CreateNotifierL( this,

                                                       KPSUidCoreApplicationUIs );

    iNotifierAPI->ListenKeyChanges( MCANotifierInterface::EMSGToneQuitKey );

    iToneFileName = HBufC::NewL( KMaxPath );

    // Get path to beep once ringing tone, first check simple sound folder.

    // Beep file might be in different folder

    // in different products.

    TFileName beepFile = PathInfo::RomRootPath();

    beepFile.Append( PathInfo::SimpleSoundsPath() );

    beepFile.Append( KBeepOnceSound );

    RFile file;

    TInt openErr = file.Open( iFs, beepFile, EFileRead );

    file.Close();

    if ( openErr == KErrNotFound || openErr == KErrPathNotFound )

        {

        // Check digital sounds folder

        beepFile.Zero();

        beepFile.Append( PathInfo::RomRootPath() );

        beepFile.Append( PathInfo::DigitalSoundsPath() );

        beepFile.Append( KBeepOnceSound );

        openErr = file.Open( iFs, beepFile, EFileRead );

        file.Close();

        }

    CHAT_DP( D_PLAIN_LIT( "CCAAudioManager::ConstructL() openErr = %d" ), openErr );

    if ( openErr == KErrNone )

        {

        iBeepRingingTone = beepFile.AllocL();

        TPtrC ptr = iBeepRingingTone->Des();

        CHAT_DP( D_PLAIN_LIT( "CCAAudioManager::ConstructL() iBeepRingingTone = %S" ), &ptr );

        }

    else

        {

        HandleError( openErr );

        }

    // get active ringing type, change events come to us later...

    iActiveProfile = iProfileApi->ActiveProfileL();

    const MProfileTones& profileTones = iActiveProfile->ProfileTones();

    const TProfileToneSettings& profileSettings = profileTones.ToneSettings();

    iRingingType = profileSettings.iRingingType;

    iActiveProfile->Release();

    iActiveProfile = NULL; // prevent further usage

    // after this, active ringing type changes are notified via the cenrep

    // notify handler callback through HandleNotifyInt

    // TRAP to catch leaves, leaves with KErrNotSupported if vibra

    // is not supported

    TRAPD( err, iVibrator = CHWRMVibra::NewL() );

    if ( err == KErrNotSupported )

        {

        // Make sure it's NULL

        iVibrator = NULL;

        }

    else

        {

        // Leave with other errors e.g. KErrNoMemory

        User::LeaveIfError( err );

        }

    CHAT_DP_FUNC_DONE( "ConstructL" );

    }

// Symbian OS default constructor can leave.

EXPORT_C CCAAudioManager* CCAAudioManager::NewL( CIMPSPresenceConnectionUi& aConnUi,

                                                 TBool aIMLauncherInvoked /*= EFalse*/ )

    {

    CCAAudioManager* self = new( ELeave ) CCAAudioManager( aConnUi, aIMLauncherInvoked );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCAAudioManager::~CCAAudioManager()

    {

    CHAT_DP_FUNC_ENTER( "~CCAAudioManager" );

    Stop(); // Stops possible playback

    if ( iActiveProfile )

        {

        iActiveProfile->Release();

        iActiveProfile = NULL; // prevent further usage

        }

    if ( iProfileApi )

        {

        iProfileApi->Release();

        }

    if ( iVibraNotifyHandler )

        {

        iVibraNotifyHandler->StopListening();

        delete iVibraNotifyHandler;

        }

    if ( iRingingTypeNotifyHandler )

        {

        iRingingTypeNotifyHandler->StopListening();

        delete iRingingTypeNotifyHandler;

        }

    if ( iRingingVolumeNotifyHandler )

        {

        iRingingVolumeNotifyHandler->StopListening();

        delete iRingingVolumeNotifyHandler;

        }

    delete iProfilesRepository;

    delete iVibraRepository;

    iApaSession.Close();

    delete iNotifierAPI;

    CHAT_DP_TXT( "delete CMdaAudioPlayerUtility" );

    iAudioPlayer->Close();

    delete iAudioPlayer;

    CHAT_DP_TXT( "delete CMdaAudioToneUtility" );

    delete iTonePlayer;

    iObservers.Close();

    delete iToneFileName;

    delete iVibrator;

    delete iBeepRingingTone;

    delete iCenRep;

    delete iSapSettings;

    iFs.Close();

    CHAT_DP_FUNC_DONE( "~CCAAudioManager" );

    }

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

// CCAAudioManager::Play

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::PlayL()

    {

    CHAT_DP_FUNC_ENTER( "Play" );

    Stop();

    TRAPD( err, DoPlayL() );

    if ( err )

        {

        NotifyObservers();

        HandleError( err );

        }

    CHAT_DP_FUNC_DONE( "Play" );

    }

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

// CCAAudioManager::DoPlayL

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::DoPlayL()

    {

    CHAT_DP_FUNC_ENTER( "DoPlayL" );

    TBuf<KMaxPath> toneFileName;

    // check if we're silent or not

    iActiveProfile = iProfileApi->ActiveProfileL();

    TBool isSilent = iActiveProfile->IsSilent();

    iActiveProfile->Release();

    iActiveProfile = NULL; // prevent further usage

    // vibrate, if it's allowed

    CHWRMVibra::TVibraModeState vibraModeState = iVibrator->VibraSettings();

    CHWRMVibra::TVibraStatus vibraStatus = iVibrator->VibraStatus();

    const TInt KIMVibraDuration = 1000; // in milliseconds

    if ( vibraModeState == CHWRMVibra::EVibraModeON &&

         vibraStatus == CHWRMVibra::EVibraStatusStopped )

        {

        iVibrator->StartVibraL( KIMVibraDuration );

        }

    // sound ordering:

    //  silent: get out.

    //  beep once: beep, and if ok, exit.

    //  if beep failed, or not active: try to play sound

    //  for this server.

    //  if it failed, play default sound.

    if ( isSilent )

        {

        // Silent profile, get out.

        CHAT_DP_TXT( "DoPlayL - Silent profile, notifying observers" );

        NotifyObservers();

        CHAT_DP_TXT( "DoPlayL - Returning" );

        return;

        }

    TInt err = KErrNone;

    if ( iRingingType == EProfileRingingTypeBeepOnce && iBeepRingingTone )

        {

        // Play beep.rng

        TRAP( err, ProcessFileL( *iBeepRingingTone ) );

        }

    if ( err != KErrNone || iRingingType != EProfileRingingTypeBeepOnce )

        {

        err = KErrNone;

        // Beep once not active, or beep once failed.

        // Try to play the sound set for this server

        TBuf<KMaxPath> toneFileName;

        GetToneFileNameL( toneFileName );

        TParsePtr parsedPtr( toneFileName );

        CHAT_DP( D_CHAT_LIT( " file = [%S] " ), &toneFileName );

        // If alert tone OFF, don't play anything

        if ( parsedPtr.NameAndExt().Compare( KProfileSilentTone ) != 0 )

            {

            // Not OFF

            TRAP( err, ProcessFileL( toneFileName ) );

            }

        if ( err )

            {

            // Trying to play default sound, because current sound failed

            err = KErrNone;

            ProcessDefaultAlertSound();

            // The above routine shows errors if it fails

            }

        }

    // Not ringing once, but left

    User::LeaveIfError( err );

    CHAT_DP_FUNC_DONE( "DoPlayL" );

    }

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

// CCAAudioManager::Stop

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::Stop()

    {

    CHAT_DP_FUNC_ENTER( "Stop" );

    if ( iAudioPlayerStatus == EAudioPlayerPlaying )

        {

        CHAT_DP_TXT(

            "Audio player is playing. CMdaAudioPlayerUtility::Stop()" );

        iAudioPlayer->Stop();

        iAudioPlayer->Close();

        iAudioPlayerStatus = EAudioPlayerReady;

        }

    if ( iTonePlayerStatus == EAudioPlayerPlaying )

        {

        CHAT_DP_TXT(

            "Tone player is playing. CMdaAudioToneUtility::CancelPlay()" );

        iTonePlayer->CancelPlay();

        iTonePlayerStatus = EAudioPlayerReady;

        }

    CHAT_DP_FUNC_DONE( "Stop" );

    }

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

// CCAAudioManager::SetVolume

// Set the volume at which the sound is played

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::SetVolume( TInt aVolume )

    {

    iRingingVolumeNotifyHandler->StopListening();

    iRingingVolume = aVolume;

    }

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

// CCAAudioManager::SetRingingType

// Sets the ringing type how the sound is played

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::SetRingingType( TProfileRingingType aRingingType )

    {

    iRingingTypeNotifyHandler->StopListening();

    iRingingType = aRingingType;

    }

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

// CCAAudioManager::SetVibra

// Sets the vibrating alert on or off

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::SetVibra( TBool aVibra )

    {

    iVibraNotifyHandler->StopListening();

    iVibra = aVibra;

    }

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

// CCAAudioManager::AddObserverL

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::AddObserverL( const MCAAudioManagerObserver* aObserver )

    {

    __ASSERT_DEBUG( aObserver, User::Panic( KPanicText, KErrArgument ) );

    // make sure that aObserver does not get appended in release mode also.

    if ( aObserver )

        {

        User::LeaveIfError( iObservers.Append( aObserver ) );

        }

    }

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

// CCAAudioManager::RemoveObserver

// (other items were commented in a header).

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

//

EXPORT_C void CCAAudioManager::RemoveObserver( const MCAAudioManagerObserver* aObserver )

    {

    TInt index( iObservers.Find( aObserver ) );

    if ( index != KErrNotFound )

        {

        iObservers.Remove( index );

        }

    }

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

// CCAAudioManager::ProcessDesSequenceL

// If des sequence is defined, prepare the audioplayer.

// (other items were commented in a header).

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

//

void CCAAudioManager::ProcessDesSequence( const TDesC8& aSequence )

    {

    CHAT_DP_FUNC_ENTER( "ProcessDesSequence" );

    Stop(); // Stops possible playback

    if ( iTonePlayerStatus == EAudioPlayerReady )

        {

        CHAT_DP_TXT( "CMdaAudioToneUtility::PrepareToPlayDesSequence" );

        iTonePlayerStatus = EAudioPlayerInitializing;

        iTonePlayer->PrepareToPlayDesSequence( aSequence );

        }

    CHAT_DP_FUNC_DONE( "ProcessDesSequence" );

    }

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

// CCAAudioManager::ProcessDefaultAlertSound

// If des sequence is defined, prepare the audioplayer.

// (other items were commented in a header).

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

//

void CCAAudioManager::ProcessDefaultAlertSound( )

    {

    iIsPlayingDefaultIMSound = ETrue;

    TRAPD( err, ProcessFileL( KNullDesC ) );

    if ( err )

        {

        HandleError( err );

        NotifyObservers();

        iIsPlayingDefaultIMSound = EFalse;

        }