diff -r 072a5fa0c63b -r c6bafb5162d8 voicerecorder/UtilsSrc/VRUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/voicerecorder/UtilsSrc/VRUtils.cpp Wed Sep 01 12:29:14 2010 +0100 @@ -0,0 +1,1172 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#ifdef RD_MULTIPLE_DRIVE +#include +#include +#endif + +#include "VoiceRecorderInternalCRKeys.h" +#include "VRUtils.h" +#include "VRConsts.h" +#include + +// 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; + } + + +// --------------------------------------------------------------------------- +// 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; + } + +// --------------------------------------------------------------------------- +// DriveValid checks the drive is valid or not +// --------------------------------------------------------------------------- +// +EXPORT_C TBool VRUtils::DriveValid( const TInt aDrive ) + { + TUint status( 0 ); + TBool flag( ETrue ); + TInt err = VRUtils::GetDriveInfo( aDrive, status ); + if ( err != KErrNone ) + { flag = EFalse; } + else + { + if ( !(status & DriveInfo::EDrivePresent) || + (status & DriveInfo::EDriveLocked) || + (status & DriveInfo::EDriveReadOnly) || + (status & DriveInfo::EDriveCorrupt) || + (status & DriveInfo::EDriveInUse) ) + { flag = EFalse; } + } + return flag; + + } + +EXPORT_C TBool VRUtils::MultipleMassStorageAvailable() + { + TBool flag( ETrue ); + TInt driveDefaultMassStorage(0); + TInt driveRemovableMassStorage(0); + TInt defaultStorageErr = DriveInfo::GetDefaultDrive( + DriveInfo::EDefaultMassStorage, driveDefaultMassStorage ); + TInt removableStorageErr = DriveInfo::GetDefaultDrive( + DriveInfo::EDefaultRemovableMassStorage, driveRemovableMassStorage ); + if ( (defaultStorageErr) || (removableStorageErr) || + ( driveDefaultMassStorage == driveRemovableMassStorage ) ) + { flag = EFalse; } + + return flag; + } + +EXPORT_C TInt VRUtils::GetRemovableMassStorageL() + { + TInt drive(0); + User::LeaveIfError( DriveInfo::GetDefaultDrive( + DriveInfo::EDefaultRemovableMassStorage , drive ) ); + return drive; + } + +#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::EDefaultMassStorage, drive ) ); + return drive; + } + + +// --------------------------------------------------------------------------- +// VRUtils::Get drive Info +// it is for multiple drive feature +// --------------------------------------------------------------------------- +// +EXPORT_C TInt VRUtils::GetDriveInfo( TInt aDrive, TUint& aDriveInfo ) + { + RFs& iFs = CCoeEnv::Static()->FsSession() ; + TInt err = DriveInfo::GetDriveStatus( iFs, aDrive, aDriveInfo ); + return err; + } +#endif + + +// End of File