/*

* Copyright (c) 2009 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    "cimalertmanager.h"

#include    "imalertdebugprint.h"      

#include    "mimalertmanagerobserver.h"

#include    "mimalertnotifierinterface.h"

#include    "imalertnotifierfactory.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>

//to get message tone file

#include <cvimpstsettingsstore.h>

// CONSTANTS

const TInt KMinVolumeLevel( 1 );

const TInt KMaxVolumeLevel( 10 );

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" ); 

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

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

// CIMAlertManager::CIMAlertManager

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

// might leave.

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

//

CIMAlertManager::CIMAlertManager()

    :   iAudioPlayerStatus( EAudioPlayerNotCreated ),

		iTonePlayerStatus( EAudioPlayerNotCreated ),

        iIsPlayingDefaultIMSound( EFalse )

    {

    }

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

// CIMAlertManager::ConstructL

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

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

//

void CIMAlertManager::ConstructL()

    {

    CHAT_DP_FUNC_ENTER("ConstructL");    

    iProfileApi = CreateProfileEngineL();

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

    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 = IMAlertNotifierFactory::CreateNotifierL( this );

    iNotifierAPI->ListenKeyChanges( MIMAlertNotifierInterface::EMSGToneQuitKey );

    iToneFileName = HBufC::NewL( KMaxPath );

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

    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( "CIMAlertManager::ConstructL() openErr = %d" ), openErr );

    if ( openErr == KErrNone )

        {

        iBeepRingingTone = beepFile.AllocL();

        TPtrC ptr = iBeepRingingTone->Des();

        CHAT_DP( D_PLAIN_LIT( "CIMAlertManager::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 );

        }

    iSettingsStore = CVIMPSTSettingsStore::NewL();

    CHAT_DP_FUNC_DONE("ConstructL");

    }

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

// CIMAlertManager::NewL

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

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

EXPORT_C CIMAlertManager* CIMAlertManager::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIMAlertManager::~CIMAlertManager

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

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

CIMAlertManager::~CIMAlertManager()

    {

    CHAT_DP_FUNC_ENTER("~CIMAlertManager");

    Stop(); // Stops possible playback

    if ( iActiveProfile )

        {

        iActiveProfile->Release();

        iActiveProfile = NULL; // prevent further usage

        }

    if ( iProfileApi ) 

        {

        iProfileApi->Release();

        iProfileApi = NULL;

        }

    if ( iVibraNotifyHandler )

        {

        iVibraNotifyHandler->StopListening();

        delete iVibraNotifyHandler;

        iVibraNotifyHandler = NULL;

        }

    if ( iRingingTypeNotifyHandler )

        {

        iRingingTypeNotifyHandler->StopListening();

        delete iRingingTypeNotifyHandler;

        iRingingTypeNotifyHandler = NULL;

        }

    if ( iRingingVolumeNotifyHandler )

        {

        iRingingVolumeNotifyHandler->StopListening();

        delete iRingingVolumeNotifyHandler;

        iRingingVolumeNotifyHandler = NULL;

        }

    if(iProfilesRepository)

        {

        delete iProfilesRepository;

        iProfilesRepository = NULL;

        }

    if(iVibraRepository)

        {

        delete iVibraRepository;

        iVibraRepository = NULL;

        }

    iApaSession.Close();

    if(iNotifierAPI)

        {

        delete iNotifierAPI;

        iNotifierAPI = NULL;

        }

    if(iAudioPlayer)

        {

        CHAT_DP_TXT( "delete CMdaAudioPlayerUtility" );

        iAudioPlayer->Close();

        delete iAudioPlayer;

        iAudioPlayer = NULL;

        }

    if(iTonePlayer)

        {

        CHAT_DP_TXT( "delete CMdaAudioToneUtility" );

        delete iTonePlayer;

        iTonePlayer = NULL;

        }

    iObservers.Close();

    if(iToneFileName)

        {

        delete iToneFileName;

        iToneFileName = NULL;

        }

    if(iVibrator)

        {

        delete iVibrator;

        iVibrator = NULL;

        }

    if(iBeepRingingTone)

        {

        delete iBeepRingingTone;

        iBeepRingingTone = NULL;

        }

    iFs.Close();

    if(iSettingsStore)

        {

        delete iSettingsStore;

        iSettingsStore = NULL;

        }

    CHAT_DP_FUNC_DONE("~CIMAlertManager");

    }

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

// CIMAlertManager::Play

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

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

//

EXPORT_C void CIMAlertManager::PlayL(TUint32 aServiceId)

    {

    CHAT_DP_FUNC_ENTER("Play");

    TInt emergencyCallOngoing(0);

    TInt err = RProperty::Get( KPSUidCtsyEmergencyCallInfo, KCTSYEmergencyCallInfo, emergencyCallOngoing );

    if( !emergencyCallOngoing )

        {

        Stop();

        TRAPD( err, DoPlayL(aServiceId) );

        if( err )

            {

            HandleError( err );

            }

        }

    CHAT_DP_FUNC_DONE("Play");

    }

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

// CIMAlertManager::DoPlayL

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

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

//

EXPORT_C void CIMAlertManager::DoPlayL(TUint32 aServiceId)

    {

    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();

    // TODO: Find from Nikhil what the behaviour should be if Vibra is already

    // on and you get a new message. Aare you supposed to truncate the existing

    // vibration and start afresh or let the existing vibration continue?

    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 - 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, aServiceId );

		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 ) );        

            }

        }

    // Not ringing once, but left

    User::LeaveIfError( err );

    CHAT_DP_FUNC_DONE("DoPlayL");

    }

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

// CIMAlertManager::Stop

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

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

//

EXPORT_C void CIMAlertManager::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");

    }

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

// CIMAlertManager::SetVolume

// Set the volume at which the sound is played

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

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

//

EXPORT_C void CIMAlertManager::SetVolume( TInt aVolume )

    {

    iRingingVolumeNotifyHandler->StopListening();

    iRingingVolume = aVolume;

    }

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

// CIMAlertManager::SetRingingType

// Sets the ringing type how the sound is played

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

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

//

EXPORT_C void CIMAlertManager::SetRingingType( TProfileRingingType aRingingType )

    {

    if(iRingingTypeNotifyHandler)

        {

        iRingingTypeNotifyHandler->StopListening();

        iRingingType = aRingingType;

        }

    }

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

// CIMAlertManager::SetVibra

// Sets the vibrating alert on or off

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

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

//

EXPORT_C void CIMAlertManager::SetVibra( TBool aVibra )

    {

    if(iVibraNotifyHandler)

        {

        iVibraNotifyHandler->StopListening();

        iVibra = aVibra;

        }

    }

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

// CIMAlertManager::AddObserverL

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

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

//

EXPORT_C void CIMAlertManager::AddObserverL( const MIMAlertManagerObserver* aObserver )

	{

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

	if( aObserver )  

		{

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

		}

	}

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

// CIMAlertManager::RemoveObserver

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

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

//

EXPORT_C void CIMAlertManager::RemoveObserver( const MIMAlertManagerObserver* aObserver )

	{

	TInt index( iObservers.Find( aObserver ) );

	if( index != KErrNotFound )

		{

		iObservers.Remove( index );

		}

	}

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

// CIMAlertManager::ProcessFileL

// If filename is defined, prepare the audioplayer.

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

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

//

void CIMAlertManager::ProcessFileL( const TDesC& aFileName )

    {

    CHAT_DP_FUNC_ENTER("ProcessFileL");

    TFileName *fileName = new (ELeave) TFileName();

    CleanupStack::PushL( fileName );

    // if filename is empty, use default sound

    if ( aFileName.Length() == 0 )

        {

        return;

        }

    else

        {