/*

* Copyright (c) 2002-2006 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 contains a collection of small static utility functions

*     needed all around the application. The class has no prefix letter

*

*

*/

// INCLUDES

#include <eikapp.h>

#include <eikenv.h>

#include <bautils.h>

#include <centralrepository.h>

#include <coemain.h>

#include <f32file.h>

#include <StringLoader.h>

#include <AknGlobalNote.h>

#include <aknnotewrappers.h>

#include <e32property.h>

#include <ctsydomainpskeys.h>

#include <pathinfo.h>

#include <featmgr.h>

#include <avkon.rsg>

#include <e32math.h>

#include <voicerecorder.rsg>

#include <VoiceRecorderUID.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#include <pathinfo.h>

#endif

#include "VoiceRecorderInternalCRKeys.h"

#include "VRUtils.h"

#include "VRConsts.h"

#include <bldvariant.hrh>

// CONSTANTS

_LIT( KVRAMRFileNameExtension,   ".amr" );

_LIT( KVRWAVFileNameExtension,   ".wav" );

// added for AAC

#ifdef  __AAC_ENCODER_PLUGIN   

_LIT( KVRAAC_LCFileNameExtension,".mp4" );

#endif

_LIT( KVROneToNineClipCountFormat, "%02d" ); // used with clip numbers 1..9

_LIT( KVRDefaultClipCountFormat, "%d" );	// used with clip numbers 10->

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

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

// VRUtils::MemoStoreDirectoryL

// Checks what is the current storage place and returns the corresponding path

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

//

EXPORT_C void VRUtils::MemoStoreDirectoryL( TDes &aPath )

	{

	TFileName phoneMemoryPath;

#ifndef RD_MULTIPLE_DRIVE

	if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )

		{

		TVRMemoStore memoStore = MemoStoreL();

		if ( memoStore == EMemoStorePhoneMemory )

			{

			phoneMemoryPath = PathInfo::PhoneMemoryRootPath();

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

			aPath.Copy( phoneMemoryPath );

			return;

			}

		else

			{

			// MMC is the selected memo store. Check if it's available.

			TVRDriveInfo mmcInfo;

			GetMMCInfo( mmcInfo );

			if ( mmcInfo.iDrivePresent && !mmcInfo.iDriveLocked &&

				!mmcInfo.iDriveCorrupted && !mmcInfo.iDriveReadOnly )

				{

				// MMC usage is OK.

				TFileName mmcPath = PathInfo::MemoryCardRootPath();

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

				aPath.Copy( mmcPath );

				return;

				}

			else

				{

				// MMC is unavailable => return phone memory path

				phoneMemoryPath = PathInfo::PhoneMemoryRootPath();

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

				aPath.Copy( phoneMemoryPath );

				return;

				}

			}

		}

	else

		{

		phoneMemoryPath = PathInfo::PhoneMemoryRootPath();

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

		aPath.Copy( phoneMemoryPath );

		return;

		}

// using multiple drive

#else

		TInt memoDrive = MemoDriveL();

		TInt defaultDrive(0);

        User::LeaveIfError( defaultDrive = DefaultMemoDriveL());

        //default drive

		if ( memoDrive == defaultDrive )

			{

            User::LeaveIfError( PathInfo::GetRootPath( phoneMemoryPath, memoDrive ) );

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

			aPath.Copy( phoneMemoryPath );

			return;

			}

		// other drives

		else

			{			

            TUint status( 0 );

            TInt err = VRUtils::GetDriveInfo(memoDrive, status);

            // check if drive status is ok 

			if ( ( err == KErrNone ) && (status & DriveInfo::EDrivePresent) && !(status & DriveInfo::EDriveLocked) &&

				!( status & DriveInfo::EDriveCorrupt ) && !( status & DriveInfo::EDriveReadOnly ) )

				{

				// Drive usage is OK.

                User::LeaveIfError( PathInfo::GetRootPath( phoneMemoryPath, memoDrive ) );

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

			    aPath.Copy( phoneMemoryPath );

			    return;

				}

			// if not ok, save to default device drive

			else

				{

            memoDrive = defaultDrive;

            User::LeaveIfError( PathInfo::GetRootPath( phoneMemoryPath, memoDrive ) );

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

			aPath.Copy( phoneMemoryPath );

			return;

				}

			}

#endif

	}

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

// VRUtils::SetMemoStoreL

// 

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

//

EXPORT_C void VRUtils::SetMemoStoreL( TVRMemoStore aMemory )

	{

	if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )

		{

		SetSettingValueL( KVRMemoStore, aMemory );

		}

	else

		{

		__ASSERT_DEBUG( ETrue, User::Panic( KVRPanic, EPanicInvalidSetting ) );

		}

	}

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

// VRUtils::MemoStoreL

// 

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

//

EXPORT_C TVRMemoStore VRUtils::MemoStoreL()

	{

	// Phone memory is the default

	if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )

		{

		TInt ret = SettingValueL( KVRMemoStore,

								EMemoStorePhoneMemory );

		return static_cast< TVRMemoStore >( ret );

		}

	else

		{

		return EMemoStorePhoneMemory;

		}

	}

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

// VRUtils::DefaultSpeakerL

// 

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

//

EXPORT_C TVRSpeaker VRUtils::DefaultSpeakerL()

	{

	if ( FeatureManager::FeatureSupported( KFeatureIdKeypadNoVoiceKey ) &&

		FeatureManager::FeatureSupported( 

							KFeatureIdApplicationControllableAudioRouting ) )

		{

		return ( TVRSpeaker ) SettingValueL( KVRDefaultSpeaker, ESpeakerIhf );

		}

	else

		{

		return ESpeakerIhf;

		}

	}

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

// VRUtils::SetDefaultSpeakerL

// 

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

//

EXPORT_C void VRUtils::SetDefaultSpeakerL( const TVRSpeaker aSpeaker )

	{

	if ( FeatureManager::FeatureSupported( KFeatureIdKeypadNoVoiceKey ) &&

		FeatureManager::FeatureSupported( 

							KFeatureIdApplicationControllableAudioRouting ) )

		{

		SetSettingValueL( KVRDefaultSpeaker, aSpeaker );

		}

	else

		{

		__ASSERT_DEBUG( ETrue, User::Panic( KVRPanic, EPanicInvalidSetting ) );

		}

	}

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

// VRUtils::QualityL

// 

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

//

EXPORT_C TVRQuality VRUtils::QualityL()

	{

    if ( VRUtils::FeatureEnabled( EVRFeatureShowQualitySetting ) )

        {   	

     	return ( TVRQuality ) SettingValueL( KVRQuality, 

     											 EQualityMMSOptimized );

 		}

	else

		{

		return EQualityMMSOptimized;

		}

	}

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

// VRUtils::SetQualityL

// 

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

//

EXPORT_C void VRUtils::SetQualityL( const TVRQuality aQuality )

	{

    if ( VRUtils::FeatureEnabled( EVRFeatureShowQualitySetting ) )

        {

		SetSettingValueL( KVRQuality, aQuality );

		}

	else

		{

		__ASSERT_DEBUG( ETrue, User::Panic( KVRPanic, EPanicInvalidSetting ) );

		}

	}

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

// VRUtils::SetDefaultVolumeL

// 

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

//

EXPORT_C void VRUtils::SetDefaultVolumeL( const TVRSpeaker aSpeaker,

	const TInt aVolume )

	{

	switch ( aSpeaker )

		{

		case ESpeakerEarPiece:

			{

			SetSettingValueL( KVREarPieceVolume, aVolume );

			break;

			}

		case ESpeakerIhf:

			{

			SetSettingValueL( KVRIHFVolume, aVolume );

			break;

			}

		default:

			{

			break;

			}

		}	

	return;

	}

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

// VRUtils::DefaultVolumeL

// 

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

//

EXPORT_C TInt VRUtils::DefaultVolumeL( const TVRSpeaker aSpeaker )

	{

	TInt volume( KVRDefaultVolume );

	switch ( aSpeaker )

		{

		case ESpeakerEarPiece:

			{

			volume = SettingValueL( KVREarPieceVolume, KVRDefaultVolume );

			break;

			}

		case ESpeakerIhf:

			{

			volume = SettingValueL( KVRIHFVolume, KVRDefaultVolume );

			break;

			}

		default:

			{

			break;

			}

		}

	return volume ? volume : KVRDefaultVolume;

	}

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

// VRUtils::SetSettingValueL, 

// save the data to central repository

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

//

void VRUtils::SetSettingValueL( const TUint32 aKey, const TInt aValue )

	{

    CRepository* repository = CRepository::NewL( KCRUidVoiceRecorder );

    CleanupStack::PushL( repository );

    User::LeaveIfError( repository->Set( aKey, aValue ) );

    CleanupStack::PopAndDestroy( repository );

	}

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

// VRUtils::SettingValueL

// 

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

//

TInt VRUtils::SettingValueL( const TUint32 aKey, const TInt aDefaultValue )

	{

    TInt data;

    CRepository* repository = CRepository::NewL( KCRUidVoiceRecorder );

	CleanupStack::PushL( repository );

	// Get the value, create the key if no value was found

    if ( repository->Get( aKey, data ) != KErrNone )

        {

        User::LeaveIfError( repository->Create( aKey, aDefaultValue ) );

        data = aDefaultValue;

        }

    CleanupStack::PopAndDestroy( repository );

	return data;

	}

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

// VRUtils::GetMMCInfo

// 

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

//

EXPORT_C void VRUtils::GetMMCInfo( TVRDriveInfo& aMMCInfo )

    {

	if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )

		{

		TDriveInfo driveInfo;

		TVolumeInfo volumeInfo;

		RFs& fss = CCoeEnv::Static()->FsSession() ;

		TInt err( fss.Drive( driveInfo, EDriveE ) );

		if ( driveInfo.iType != EMediaNotPresent )

			{

			aMMCInfo.iDrivePresent = ETrue;

			if ( fss.Volume( volumeInfo, EDriveE ) == KErrCorrupt )

				{

				aMMCInfo.iDriveCorrupted = ETrue;

				}

			else

				{

				aMMCInfo.iDriveCorrupted = EFalse;

				}

			}

		else

			{

			aMMCInfo.iDriveCorrupted = EFalse;

			aMMCInfo.iDrivePresent = EFalse;

			}

		if ( driveInfo.iMediaAtt & KMediaAttLocked || err == KErrLocked )

			{

			aMMCInfo.iDriveLocked = ETrue;

			}

		else

			{

			aMMCInfo.iDriveLocked = EFalse;

			}

		if ( driveInfo.iMediaAtt & KMediaAttWriteProtected )

			{

			aMMCInfo.iDriveReadOnly = ETrue;

			}

		else

			{

			aMMCInfo.iDriveReadOnly = EFalse;

			}

		if ( volumeInfo.iFree ==0 )

			{

			aMMCInfo.iDriveFull = ETrue;

			}

		else

			{

			aMMCInfo.iDriveFull = EFalse;

			}

		}

    }

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

// VRUtils::ShowMemoryFullConfirmationQuery

// 

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

//

EXPORT_C void VRUtils::ShowMemoryFullConfirmationQuery( TBool aMmc )

	{

	// Error ignored. If the note fails, there's nothing to do.

	TRAP_IGNORE( ShowMemoryFullConfirmationQueryL( aMmc ) );

	}

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

// VRUtils::UnsupportedCallTypeOngoing

// 

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

//

EXPORT_C TBool VRUtils::UnsupportedCallTypeOngoing( TBool aShowNote )

	{

	TBool unsupported( EFalse );

	TInt value( 0 );

	TInt err( 0 );

    RProperty property;

    err = property.Attach( KPSUidCtsyCallInformation, KCTsyCallState );

	if ( err )

		{

		return EFalse;

		}

    property.Get( value );

    switch ( value )

	    {

    	case EPSCTsyCallStateUninitialized:

    	case EPSCTsyCallStateNone:

    		{ // No any kind of call in progress

    		return EFalse;

    		}

		default: // Call in progress, check if it is videocall

		    {

		    err = property.Attach( KPSUidCtsyCallInformation, KCTsyCallType);

        	if ( err )

        		{

        		return EFalse;

        		}

        	value = 0;

    		property.Get( value );

			break;

		    }

    	}

	switch( value )

		{

		// Video call ongoing

		case EPSCTsyCallTypeH324Multimedia:

			{

			unsupported = ETrue;

			if ( aShowNote )

				{

				// If the note fails, it's no big deal

				TRAP_IGNORE( ShowUnsupportedCallTypeNoteL( 

					R_VR_VIDEO_CALL_INFONOTE_LABEL ) );

				}

			break;			

			}

		// Voip call ongoing

		case EPSCTsyCallTypeVoIP:

			{

			unsupported = ETrue;

			if ( aShowNote )

				{

				// If the note fails, it's no big deal

				TRAP_IGNORE( ShowUnsupportedCallTypeNoteL( 

					R_VR_INTERNET_CALL_INFONOTE_LABEL ) );

				}

			break;			

			}			

		}

	return unsupported;