--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/voicerecorder/UtilsSrc/VRUtils.cpp Thu Dec 17 08:46:57 2009 +0200
@@ -0,0 +1,1124 @@
+/*
+* 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 );
+ VRUtils::GetDriveInfo(memoDrive, status);
+ // check if drive status is ok
+ if ( (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;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::ShowMemoryFullConfirmationQueryL
+//
+// ---------------------------------------------------------------------------
+//
+void VRUtils::ShowMemoryFullConfirmationQueryL( TBool aMmc )
+ {
+ CAknGlobalNote* note = NULL;
+
+ note = CAknGlobalNote::NewLC();
+
+ HBufC* label = NULL;
+ TInt noteId( 0 );
+ if ( aMmc )
+ {
+ noteId = R_VR_MEMORY_MMC_WARNING;
+ }
+ else
+ {
+ noteId = R_VR_MEMORY_WARNING;
+ }
+
+ label = StringLoader::LoadLC( noteId );
+
+ note->SetSoftkeys( R_AVKON_SOFTKEYS_OK_EMPTY );
+ note->ShowNoteL( EAknGlobalWarningNote, *label );
+ CleanupStack::PopAndDestroy( 2 ); // label, note;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::ShowUnsupportedCallTypeNoteL
+//
+// ---------------------------------------------------------------------------
+//
+void VRUtils::ShowUnsupportedCallTypeNoteL( TInt aResourceId )
+ {
+ CAknInformationNote* infoNote;
+ HBufC* noteText;
+
+ noteText = CEikonEnv::Static()->
+ AllocReadResourceLC( aResourceId );
+
+ infoNote = new( ELeave ) CAknInformationNote( ETrue );
+ infoNote->ExecuteLD( *noteText );
+
+ CleanupStack::PopAndDestroy( noteText );
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::MaxLengthL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt VRUtils::MaxLengthL()
+ {
+ // If no value can be retrieved, use 60 minutes as max length
+ TInt value( 0 );
+
+#ifdef __AAC_ENCODER_PLUGIN // mp4 is supported now.
+ if (QualityL() == EQualityHigh)
+ {
+ TRAPD( err, value = SettingValueL( KVRAacRecordLength,
+ KVRDefaultAacRecordLength ) );
+
+ if ( err || value <= 0 || value > 9999 )
+ {
+ return KVRDefaultAacRecordLength;
+ }
+ }
+#endif
+ TRAPD( err, value = SettingValueL( KVRMaxRecordTime,
+ KVRDefaultMaxLength ) );
+
+ if ( err || value <= 0 || value > 9999 )
+ {
+ return KVRDefaultMaxLength;
+ }
+
+
+ return value;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::FeatureEnabled
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool VRUtils::FeatureEnabled( TVRFeature aFeature )
+ {
+ TBool ret( EFalse );
+ TInt data( 0 );
+
+ TRAPD( err, data = SettingValueL( KVRVariationFlags, 0 ) );
+ if( err != KErrNone )
+ {
+ return EFalse;
+ }
+
+ // Compare feature to bitmask
+ if ( data & aFeature )
+ {
+ ret = ETrue;
+ }
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::GenerateUniqueFilename
+// Generates unique filename that doesn't exist in the directories where VR
+// operates in. Unique filename is generated in Media Gallery sense so that no
+// two sound clips can have same name there
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void VRUtils::GenerateUniqueFilenameL( RFs& aFs, TFileName& aName,
+ TVRFiletype aType )
+ {
+
+ TBuf< VRLABELMAXLENGTH > valueStr;
+ TBuf< VRLABELMAXLENGTH > formatStr;
+ TFileName name( aName );
+ TFileName clipName; // Used for file existence checking
+ TBool fileExists( EFalse );
+
+ // Get current count from cenrep
+ TInt value( MemoCount() );
+
+ TBool uniqueFound( EFalse );
+
+ // First memo
+ if ( !value )
+ {
+ StringLoader::Load( formatStr, R_VOREC_FIRST_MEMO_NAME );
+ name.Append( formatStr );
+ clipName.Append( formatStr );
+
+ TRAPD( err1, fileExists = DoesFileExistL( aFs, clipName ) );
+ if ( err1 )
+ {
+ // if error occurs, no much to do->generate new filename
+ fileExists = ETrue;
+ }
+
+ AppendExtension( name, aType );
+
+ if ( fileExists )
+ {
+ // Memo exists, continue name generation with next name
+ ++value;
+ }
+ else
+ {
+ uniqueFound = ETrue;
+ ++value; // This is saved to cenrep
+ }
+ }
+
+ // Continue generation
+ if ( !uniqueFound )
+ {
+ StringLoader::Load( formatStr, R_VOREC_DEFAULT_MEMO_NAME );
+
+
+ // Loop until unique filename is generated
+ FOREVER
+ {
+ // 0 is added before clip number when number is between 1 and 9
+ if(value >= 1 && value <= 9)
+ {
+ valueStr.Format( KVROneToNineClipCountFormat, value);
+ }
+ // no addings for clip numbers 10->
+ else
+ {
+ valueStr.Format( KVRDefaultClipCountFormat, value);
+ }
+
+ StringLoader::Format( name, formatStr, -1, valueStr );
+
+ // name copied before the path is added
+ clipName = name;
+
+ // Insert path to beginning
+ name.Insert( 0, aName );
+
+ AknTextUtils::LanguageSpecificNumberConversion( name );
+
+ TRAPD( err2, fileExists = DoesFileExistL( aFs, clipName ) );
+ if ( err2 )
+ {
+ fileExists = ETrue;
+ }
+
+ AppendExtension( name, aType );
+ if ( !fileExists )
+ {
+ // Accept the name and increase value
+ // Value increasing is mandatory to prevent similarly named clips when quality
+ // or store place is changed
+ ++value;
+ break;
+ }
+ // Try next...
+ ++value;
+ }
+ }
+
+ aName = name;
+
+ // Save the new value to cenrep
+ SetMemoCount( value );
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::AppendExtension
+//
+// ---------------------------------------------------------------------------
+//
+void VRUtils::AppendExtension( TFileName& aName, TVRFiletype aType )
+ {
+ switch ( aType )
+ {
+ case EVRFileWav:
+ {
+ aName.Append( KVRWAVFileNameExtension );
+ break;
+ }
+
+//Jeffery: the following case added for the new CR
+#ifdef __AAC_ENCODER_PLUGIN
+ case EVRFileAAC_LC:
+ {
+ aName.Append( KVRAAC_LCFileNameExtension );
+ break;
+ }
+#endif
+
+ // In error case amr extension is appended
+ case EVRFileAmr:
+ default:
+ {
+ aName.Append( KVRAMRFileNameExtension );
+ break;
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::MemoCount
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt VRUtils::MemoCount()
+ {
+ // If no value can be retrieved, use zero
+ TInt value( 0 );
+ TRAPD( err, value = SettingValueL( KVRMemoCount, 0 ) );
+ if ( err != KErrNone )
+ {
+ return 0;
+ }
+ return value;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::SetMemoCount
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void VRUtils::SetMemoCount( TInt aNewCount )
+ {
+ TRAP_IGNORE( SetSettingValueL( KVRMemoCount, aNewCount ) );
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::AMRBitrateL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint VRUtils::AMRBitrateL()
+ {
+ TUint bitrate(KVRDefaultAmrBitrate);
+
+ // Fetch bitrate from
+ TRAPD( err, bitrate = SettingValueL( KVRBitrateAmr,
+ KVRDefaultAmrBitrate ) );
+
+ if ( err || bitrate <= 0 || bitrate > 12200 )
+ {
+ bitrate = KVRDefaultAmrBitrate;
+ }
+
+ return bitrate;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::AACBitrateL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint VRUtils::AACBitrateL()
+ {
+
+ TUint bitrate(KVRDefaultBitrateAac);
+
+ // Fetch bitrate from
+ TRAPD( err, bitrate = SettingValueL( KVRBitrateAac,
+ KVRDefaultBitrateAac ) );
+
+ if ( err || bitrate <= 8000 || bitrate > 288000 )
+ {
+ bitrate = KVRDefaultBitrateAac;
+ }
+ return bitrate;
+ }
+
+// ---------------------------------------------------------------------------
+// VRUtils::DoesFileExistL
+// Makes the full checking if the filename (aName) exists in the directories
+// that Voice Recorder uses for clip storage
+// ---------------------------------------------------------------------------
+//
+TBool VRUtils::DoesFileExistL( RFs& aFs, TFileName aName )
+ {
+// old memory storage
+#ifndef RD_MULTIPLE_DRIVE
+ // Storage place at the moment
+ TVRMemoStore memoStore = MemoStoreL();
+ TFileName path;
+ TFileName fileName(aName);
+
+ // The path for the current storage place
+ VRUtils::MemoStoreDirectoryL( path );
+
+ // Add the path to the filename
+ fileName.Insert( 0, path );
+
+ if ( CheckFileExistence( aFs, fileName ) )
+ {
+ return ETrue;
+ }
+
+ // Check possible alternative storage place
+ TVRMemoStore secondaryStore;
+ if ( memoStore == EMemoStorePhoneMemory )
+ {
+ if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )
+ {
+ secondaryStore = EMemoStoreMMC;
+ }
+ else
+ {
+ secondaryStore = EMemoStorePhoneMemory;
+ }
+ }
+ else
+ {
+ secondaryStore = EMemoStorePhoneMemory;
+ }
+
+ // If there is some secondary storage place to check
+ if( memoStore != secondaryStore )
+ {
+ // Temporarily change the storage place (needed by MemoStoreDirectoryL)
+ VRUtils::SetSettingValueL( KVRMemoStore, secondaryStore );
+
+ // Retrieve the path and add it to the filename
+ VRUtils::MemoStoreDirectoryL( path );
+
+ fileName = aName;
+ fileName.Insert( 0, path );
+
+ // Change back to the original
+ VRUtils::SetSettingValueL( KVRMemoStore, memoStore );
+
+ if ( CheckFileExistence( aFs, fileName ) )
+ {
+ return ETrue;
+ }
+ }
+
+// for multiple drives
+#else
+ TFileName path;
+ TFileName fileName(aName);
+
+ TDriveList allDrives;
+ TInt allDriveCount( 0 );
+
+ User::LeaveIfError(DriveInfo::GetUserVisibleDrives( aFs, allDrives, allDriveCount ));
+
+ TInt max( allDrives.Length());
+ for ( TInt i = 0; i < max; i++ )
+ {
+ if ( allDrives[ i ] )
+ {
+ TUint status( 0 );
+ VRUtils::GetDriveInfo( i, status);
+
+ if( status & DriveInfo::EDriveRemote )
+ {
+ continue;
+ }
+
+ User::LeaveIfError( PathInfo::GetRootPath( path, i) );
+ path.Append( PathInfo::DigitalSoundsPath() );
+
+ // Add the path to the filename
+ fileName.Insert( 0, path );
+
+ if ( CheckFileExistence( aFs, fileName ) )
+ {
+ return ETrue;
+ }
+
+ fileName.Copy(aName);
+ }
+ }
+#endif
+
+ return EFalse;
+
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::CheckFileExistence
+// Checks if the filename given as a parameter exists. This function checks all
+// possible extensions (in VR). Note that aName includes path but no extension.
+// ---------------------------------------------------------------------------
+//
+TBool VRUtils::CheckFileExistence( RFs& aFs, TFileName aName )
+ {
+ TFileName fileName( aName );
+
+ // AMR file
+ AppendExtension( fileName, EVRFileAmr );
+ AknTextUtils::LanguageSpecificNumberConversion( fileName );
+ if ( BaflUtils::FileExists( aFs, fileName ) )
+ {
+ return ETrue;
+ }
+
+ // WAV file
+ fileName = aName;
+ AppendExtension( fileName, EVRFileWav );
+ AknTextUtils::LanguageSpecificNumberConversion( fileName );
+ if ( BaflUtils::FileExists( aFs, fileName ) )
+ {
+ return ETrue;
+ }
+
+
+ // AAC_LC file
+ #ifdef __AAC_ENCODER_PLUGIN
+ fileName = aName;
+ AppendExtension( fileName, EVRFileAAC_LC );
+ AknTextUtils::LanguageSpecificNumberConversion( fileName );
+
+ if ( BaflUtils::FileExists( aFs, fileName ) )
+ {
+ return ETrue;
+ }
+ #endif
+
+ return EFalse;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::AACSamplerateL
+// ---------------------------------------------------------------------------
+//
+
+EXPORT_C TInt VRUtils::AACSamplerateL()
+ {
+
+ TUint samplerate( KVRDefaultSamplerateAac );
+
+ // Fetch bitrate from
+ TRAPD( err, samplerate = SettingValueL( KVRSamplerateAac,
+ KVRDefaultSamplerateAac ) );
+
+ if ( err || samplerate < 8000 || samplerate > 48000 )
+ {
+ return KVRDefaultSamplerateAac;
+ }
+
+
+ return samplerate;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::AACAudioModeL
+// ---------------------------------------------------------------------------
+//
+
+EXPORT_C TInt VRUtils::AACAudioModeL()
+ {
+
+ TUint mode( KVRDefaultStereoMonoFlag );
+
+ // Fetch audiomode from
+ TRAPD( err, mode = SettingValueL( KVRStereoMonoFlag,
+ KVRDefaultStereoMonoFlag ) );
+
+ if ( err || (mode != 1 && mode != 2))
+ {
+ return KVRDefaultStereoMonoFlag;
+ }
+
+
+ return mode;
+ }
+
+
+#ifdef RD_MULTIPLE_DRIVE
+// ---------------------------------------------------------------------------
+// VRUtils::SetMemoDriveL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void VRUtils::SetMemoDriveL( TDriveNumber aDrive )
+ {
+ if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )
+ {
+ SetSettingValueL( KVRMemoStore, aDrive );
+ }
+ else
+ {
+ __ASSERT_DEBUG( ETrue, User::Panic( KVRPanic, EPanicInvalidSetting ) );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::MemoDriveL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt VRUtils::MemoDriveL()
+ {
+ TInt defaultDrive = DefaultMemoDriveL();
+ // Phone memory is the default
+ if ( FeatureManager::FeatureSupported( KFeatureIdMmc ) )
+ {
+ TInt ret = SettingValueL( KVRMemoStore,
+ defaultDrive );
+ return static_cast< TInt >( ret );
+ }
+ else
+ {
+ return defaultDrive;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::DefaultMemoDriveL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt VRUtils::DefaultMemoDriveL()
+ {
+ TInt drive(0);
+ User::LeaveIfError( DriveInfo::GetDefaultDrive(DriveInfo::EDefaultPhoneMemory, drive ) );
+ return drive;
+ }
+
+
+// ---------------------------------------------------------------------------
+// VRUtils::Get drive Info
+// it is for multiple drive feature
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void VRUtils::GetDriveInfo( TInt aDrive, TUint& aDriveInfo )
+ {
+ RFs& iFs = CCoeEnv::Static()->FsSession() ;
+ DriveInfo::GetDriveStatus( iFs, aDrive, aDriveInfo );
+ }
+#endif
+
+
+// End of File