camerauis/cameraapp/generic/common/src/CamUtility.cpp
changeset 19 d9aefe59d544
parent 3 8b2d6d0384b0
child 21 fa6d9f75d6a6
child 28 3075d9b614e6
--- a/camerauis/cameraapp/generic/common/src/CamUtility.cpp	Tue Feb 02 00:01:39 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1708 +0,0 @@
-/*
-* Copyright (c) 2007-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:  Utility functions for the Camera Application*
-*/
-
-
-
-// INCLUDE FILES
-#include <bldvariant.hrh> // for feature definitions
-
-#include <aknappui.h>                  // CEikonEnv::Static()->FsSession()
-#include <AknSkinsInternalCRKeys.h>
-#include <aknnotewrappers.h>
-
-#include <AknCommonDialogsDynMem.h>
-#include <driveinfo.h>
-
-#include <sysutil.h>                   // SysUtil::DiskSpaceBelowCriticalLevelL()
-#include <pathinfo.h>
-#include <eikapp.h>                    // CEikApplication
-#include <collate.h>                   // TCollateMethod
-#include <e32property.h>
-#include <centralrepository.h>
-#include <MmsEngineInternalCRKeys.h>   // MMS cenrep keys
-#include <hwrmpowerstatesdkpskeys.h>
-#include <coreapplicationuisdomainpskeys.h> // USB connection 
-#include <locationtrailpskeys.h>
-#include <AvkonInternalCRKeys.h>   // KAknQwertyInputModeActive
-
-#include <layoutmetadata.cdl.h>            
-#include <aknlayoutscalable_apps.cdl.h>    
-
-#if defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)
-  #include <harvesterclient.h>
-#endif // defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)
-
-
-#include <glxcollectionmanager.h>
-
-#ifndef CAMERAAPP_PLUGIN_BUILD
-    #include <cameraapp.rsg>
-    #include <vgacamsettings.rsg>  
-#else
-    #include <gscamerapluginrsc.rsg>
-#endif //CAMERAAPP_PLUGIN_BUILD
-
-#include "CamUtility.h"
-#include "CamPanic.h"
-#include "CameraappPrivateCRKeys.h"
-#include "camuidconstants.h"
-
-
-// CONSTANTS
-const TInt KCamNhdWidth  = 640;
-const TInt KCamNhdHeight = 360;   
-
-#ifndef CAMERAAPP_PLUGIN_BUILD
-
-#include "CamAppUi.h"
-#include "CameraUiConfigManager.h"
-#include "CamResourceLookup.h"
-
-// ===========================================================================
-// CONSTANTS
-const TInt KMicSecInHalfSec  = 500000;
-const TInt KMicSecInQuartSec = 250000;
-
-const TInt KCaptureLongPress = 500; // value in milliseconds
-
-// UI EV range
-const TInt KEVCompMinVal       = -2;
-const TInt KEVCompMaxVal       =  2;
-const TInt KEVCompStepsPerUnit =  2;
-
-// Limit for burst captured images 
-const TInt KMaxBurstImages     = 18;
-
-// Timeout value for courtesyUI
-const TInt KCourtesyUiTimeoutValue  = 5;
-
-// Self-timer constants
-const TInt KMicroSecPerSec = 1000000;
-
-#endif //CAMERAAPP_PLUGIN_BUILD
-
-
-// ============================ MEMBER FUNCTIONS ===============================
-
-
-// ---------------------------------------------------------------------------
-// CamUtility::MemoryFree
-// Get free space in selected memory
-//
-// Returns: free space in selected memory (in bytes) minus the disk critical space
-// ---------------------------------------------------------------------------
-//
-
-TInt64 CamUtility::MemoryFree( 
-    //AknCommonDialogsDynMem::TMemoryTypes aMemory,
-    DriveInfo::TDefaultDrives aMemory,
-    TInt aCriticalLevel )
-    {   
-    PRINT( _L("Camera => CamUtility::MemoryFree") ); 
-    TVolumeInfo vinfo;
-    TInt error = KErrNone;
-
-    // if measuring space on memory card
-    if ( aMemory ==  DriveInfo::EDefaultRemovableMassStorage )//AknCommonDialogsDynMem::EMemoryTypeMMC )
-        {
-        error = CEikonEnv::Static()->FsSession().Volume(
-            vinfo, MemoryCardDrive() );
-        if ( error || MemoryCardStatus() != ECamMemoryCardInserted )
-            {
-        PRINT( _L("Camera <= CamUtility::MemoryFree, failed to get volume info 1!!") ); 
-            return 0;
-            }            
-        }
-    else if ( aMemory == DriveInfo::EDefaultMassStorage )//AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage )
-    	{
-        error = CEikonEnv::Static()->FsSession().Volume( 
-            vinfo, MassMemoryDrive() );
-    	}
-    else // otherwise, measuring space on the phone memory
-        {
-        error = CEikonEnv::Static()->FsSession().Volume( 
-            vinfo, PhoneMemoryDrive() );
-        }
-
-    if ( error ) // if getting the volume info failed
-        {
-        PRINT( _L("Camera <= CamUtility::MemoryFree, failed to get volume info 2!!") ); 
-        return 0; // indicate not enough space
-        }
-    PRINT( _L("Camera <= CamUtility::MemoryFree") ); 
-    return vinfo.iFree - aCriticalLevel; 
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::MemoryCardStatus
-// Returns the current status of the MMC
-// ---------------------------------------------------------------------------
-//
-TCamMemoryCardStatus CamUtility::MemoryCardStatus()
-    {
-    PRINT( _L("Camera => CamUtility::MemoryCardStatus") );    
-    TDriveInfo driveInfo;
-
-    CEikonEnv::Static()->FsSession().Drive( driveInfo, MemoryCardDrive() );
-
-    // Check if the MMC is currently locked.
-    // If mmc is locked, then driveInfo.iType is zero, therefore switch clause 
-    // below does not notice new card
-    // Check iMediaAtt instead, if media can be locked and is currently locked 
-    // and has password, then locked MMC is inserted
-
-    TCamMemoryCardStatus mmcStatus( ECamMemoryCardNotInserted );
-
-    if ( ( driveInfo.iMediaAtt & ( KMediaAttLockable|KMediaAttLocked|KMediaAttHasPassword ) ) 
-           == ( KMediaAttLockable|KMediaAttLocked|KMediaAttHasPassword ) )
-        {
-        mmcStatus = ECamMemoryCardLocked;
-        }
-    else
-        {
-        switch( driveInfo.iType )
-            {
-            case EMediaNotPresent:
-                {
-                mmcStatus = ECamMemoryCardNotInserted;
-                break;
-                }
-            default:
-                {
-                mmcStatus = ECamMemoryCardInserted;
-                break;
-                }
-            }
-        }
-    // Check that volume is valid (ie. MMC is not corrupted)
-    TVolumeInfo volumeInfo;
-    TInt error = CEikonEnv::Static()->FsSession().Volume( volumeInfo, MemoryCardDrive() );
-    if ( error )
-        {
-        mmcStatus = ECamMemoryCardNotInserted;
-        }        
-    PRINT( _L("Camera <= CamUtility::MemoryCardStatus") );    
-    return mmcStatus;
-    }
-
-
-// ---------------------------------------------------------------------------
-// CamUtility::MemoryCardDrive
-// Get drive number for memory card.
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::MemoryCardDrive()
-    {
-    // Get the root path of the default memory card.
-    TInt drive;
-    TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive );
-    if ( err != KErrNone )
-    	{
-    	return err;
-    	}
-    TFileName path;
-    err = PathInfo::GetRootPath( path, drive );
-    if ( err != KErrNone )
-    	{
-    	return err;
-    	}
-    TInt res = 0;
-    err = RFs::CharToDrive( path[0], res );
-    __ASSERT_ALWAYS( !err, CamPanic( ECamPanicFileSystemError ) );
-    // return the memory card drive number
-    return res;
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::PhoneMemoryDrive
-// Get drive number for phone memory.
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::PhoneMemoryDrive()
-    {
-    // Get the root path of the default phone memory.
-    TInt drive;
-    TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, drive );
-    if ( err != KErrNone )
-    	{
-    	return err;
-    	}
-    TFileName path;
-    err = PathInfo::GetRootPath( path, drive );
-    if ( err != KErrNone )
-    	{
-    	return err;
-    	}
-    TInt res = 0;
-    err = RFs::CharToDrive( path[0], res );
-    __ASSERT_ALWAYS( !err, CamPanic( ECamPanicFileSystemError ) );
-    // return the phone memory drive number
-    return res;
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::MassMemoryDrive
-// Get drive number for mass storage memory.
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::MassMemoryDrive()
-	{
-    // Get the root path of the default mass storage memory.
-    TInt drive;
-    TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive );
-    if ( err != KErrNone )
-    	{
-    	return err;
-    	}
-    TFileName path;
-    err = PathInfo::GetRootPath( path, drive );
-    if ( err != KErrNone )
-    	{
-    	return err;
-    	}
-    TInt res = 0;
-    err = RFs::CharToDrive( path[0], res );
-    __ASSERT_ALWAYS( !err, CamPanic( ECamPanicFileSystemError ) );
-    // return the mass storage memory drive number
-    return res;
-	}
-
-
-TInt CamUtility::GetDriveTypeFromDriveNumber( TInt aDrive )
-	{
-	TInt drive;
-	TInt returnVal = DriveInfo::EDefaultPhoneMemory;
-	DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, drive );
-	if ( drive == aDrive )
-		{
-		returnVal = DriveInfo::EDefaultPhoneMemory;
-		}
-	DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive );
-	if ( drive == aDrive )
-		{
-		returnVal = DriveInfo::EDefaultMassStorage;
-		}
-	DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive );
-	if ( drive == aDrive )
-		{
-		returnVal = DriveInfo::EDefaultRemovableMassStorage;
-		}
-    return returnVal;
-	}
-
-// ---------------------------------------------------------------------------
-// CamUtility::MapToSettingsListMemory
-// Return settings list mapped value
-// ---------------------------------------------------------------------------
-//   
-
-TInt CamUtility::MapToSettingsListMemory( TInt aStorage )
-    {
-    TInt mappedMemory;
-    switch ( aStorage )
-        {
-        case ECamMediaStoragePhone:
-            {
-            mappedMemory = DriveInfo::EDefaultPhoneMemory;
-            }
-            break;
-        case ECamMediaStorageCard:
-            {
-            mappedMemory = DriveInfo::EDefaultRemovableMassStorage;
-            }
-            break;
-        case ECamMediaStorageMassStorage:
-            {
-            mappedMemory = DriveInfo::EDefaultMassStorage;
-            }
-            break;
-        default:
-            {
-            mappedMemory = KErrNotFound;
-            }
-            break;
-        }
-    return mappedMemory;        
-    }
-    
-// ---------------------------------------------------------------------------
-// CamUtility::MapFromSettingsListMemory
-// Return camera storage location mapped from settings list value
-// ---------------------------------------------------------------------------
-// 
-TInt CamUtility::MapFromSettingsListMemory( TInt aStorage )
-    {
-    TInt mappedMemory;
-    switch ( aStorage )
-        {
-        case DriveInfo::EDefaultPhoneMemory:
-            {
-            mappedMemory = ECamMediaStoragePhone;
-            }
-            break;
-        case DriveInfo::EDefaultRemovableMassStorage:
-            {
-            mappedMemory = ECamMediaStorageCard;
-            }
-            break;
-        case DriveInfo::EDefaultMassStorage:
-            {
-            mappedMemory = ECamMediaStorageMassStorage;
-            }
-            break;
-        default:
-            {
-            mappedMemory = KErrNotFound;
-            }
-            break;
-        }
-    return mappedMemory;        
-    }    
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetUniqueNameL
-// Suggest a new unique filename using the name stub provided in aFilename
-// and adding a numbered postfix to ensure uniqueness
-// The full filename is returned in aFilePath. The name of the file only, is
-// returned in aFilename
-// ---------------------------------------------------------------------------
-//
-void CamUtility::GetUniqueNameL( TDes& aFilePath, 
-                                 TDes& aFilename, 
-                                 TInt aSuggestedNumeral,
-                                 const TDesC& aExt )
-    {
-    PRINT( _L("Camera => CamUtility::GetUniqueNameL") );    
-    // Leave if there is a problem with the passed directory path.
-    TEntry entry;
-    RFs rfs;
-    User::LeaveIfError( rfs.Connect( ) );
-    CleanupClosePushL( rfs );
-    User::LeaveIfError( rfs.Entry( aFilePath, entry ) );
-	// check it actually is a directory
-    if( !entry.IsDir() )
-        {
-        PRINT( _L("Camera => CamUtility::GetUniqueNameL not dir") );
-        User::Leave( KErrCorrupt );
-        }   
-
-    TInt namelen = aFilename.Length();
-
-    TFileName nameBase( aFilename.Left( namelen ) );
-
-    TBool done = EFalse;
-    TInt counter = aSuggestedNumeral;
-
-    RFs& fs = CEikonEnv::Static()->FsSession();
-
-    while ( !done )
-        {
-        // Generate new name
-        FormatFileName( counter, nameBase, aFilename );
-
-        TFileName newPath( aFilePath );
-        newPath.Append( aFilename );
-        newPath.Append( aExt );
-
-        // define new instance of TEntry to prevent LINT error
-        TEntry newEntry;
-        TInt ferr = fs.Entry( newPath, newEntry );        
-        // if there is no file in the current location with this name
-        if ( ferr == KErrNotFound )
-            {
-            done = ETrue;
-            aFilePath.Copy( newPath );
-            }
-        else if( ferr == KErrNone )// the filename has already been used in this location
-            {
-            // try the next number
-            ++counter;
-            }
-        else
-            {
-            User::Leave( ferr );
-            }            
-        }
-    CleanupStack::PopAndDestroy( &rfs );
-    PRINT( _L("Camera => CamUtility::GetUniqueNameL") );    
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::FormatFileName
-// Generate a file name based on base name and counter.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::FormatFileName( TUint aCounter,
-                                 const TDesC& aBaseName,
-                                 TDes& aFilename )
-    {
-    const TUint KMax3Digits = 999;
-    _LIT( KCamNameFormatFirst, "%S" );      	// "Photo"
-    _LIT( KCamNameFormat3Digits, "%S%03d" );    // "Photo001"
-    _LIT( KCamNameFormat4Digits, "%S%d" );    // "Photo1234"
-   
-    // if the number is 0
-    if ( aCounter == 0 )
-        {
-        aFilename.Format( KCamNameFormatFirst, &aBaseName );
-        }
-    else if ( aCounter <= KMax3Digits ) // the number is 1 - 999
-        {
-        aFilename.Format( KCamNameFormat3Digits, &aBaseName, aCounter );
-        } 
-    else // the number is > 999
-        {
-        aFilename.Format( KCamNameFormat4Digits, &aBaseName, aCounter );
-        }
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::CheckFileNameValidityL
-// Checks if given filename contains illegal characters or
-// is otherwise illegal.
-// ---------------------------------------------------------------------------
-//
-TBool CamUtility::CheckFileNameValidityL( const TDesC& aFilename ) 
-    {
-    // For filename validity checking
-    _LIT( KSingleDot, "." );
-    _LIT( KDoubleDot, ".." );
-    _LIT( KBackslash, "\\" );
-
-    // "." and ".." are not valid filenames
-    if ( aFilename.Compare( KSingleDot ) == 0 ||
-         aFilename.Compare( KDoubleDot ) == 0 )
-        {
-        CAknNoteWrapper* note = new ( ELeave ) CAknNoteWrapper();
-        note->ExecuteLD( R_CAM_UNSUITABLE_FILENAME );
-        return EFalse;
-        }
-
-    // No backslashes in filenames.
-    // File server checks for other special characters.
-    if ( aFilename.Find( KBackslash ) != KErrNotFound ||
-         !CCoeEnv::Static()->FsSession().IsValidName( aFilename ) )
-        {
-        CAknNoteWrapper* note = new ( ELeave ) CAknNoteWrapper();
-        note->ExecuteLD( R_CAM_ILLEGAL_CHARACTERS );
-        return EFalse;
-        }
-
-    // File name is okay.
-    return ETrue;
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::FormatDateFileNameL
-// Generate a file name based on date and counter.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::FormatDateFileNameL( TDes& aFilename )
-    {
-    const TInt KCamMaxDateLen = 8;
-
-    _LIT( KCamNameFormatFirst, "%S" );      // "Image"
-
-    TBuf<KCamMaxDateLen> date;
-    GetCurrentDateForNameBaseL( date );
-
-    aFilename.Format( KCamNameFormatFirst, &date );
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetCurrentDateForNameBaseL
-// Format current date into given descriptor in a format
-// suitable for file names.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::GetCurrentDateForNameBaseL( TDes& aBuffer )
-    {
-    const TInt KCamDateFormatLength = 8;
-    _LIT( KCamEuropeanDateFormat, "%F%D%M%Y" );
-    _LIT( KCamAmericanDateFormat, "%F%M%D%Y" );
-    _LIT( KCamJapaneseDateFormat, "%F%Y%M%D" );
-
-    TTime now;
-    now.HomeTime();
-    TLocale locale;
-    TBuf<KCamDateFormatLength> dateFormat;
-
-    switch ( locale.DateFormat() )
-        {
-        case EDateAmerican:
-            {
-            dateFormat = KCamAmericanDateFormat;
-            break;
-            }
-
-        case EDateJapanese:
-            {
-            dateFormat = KCamJapaneseDateFormat;
-            break;
-            }
-
-        case EDateEuropean:
-        default:
-            {
-            dateFormat = KCamEuropeanDateFormat;
-            break;
-            }
-        }
-
-    now.FormatL( aBuffer, dateFormat );
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::ResourceFileName
-// Return the name and path of the application MBM file.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::ResourceFileName( TDes& aResName )
-    {
-    _LIT(KResName, "z:\\resource\\apps\\cameraapp.mbm");
-
-    aResName = KResName();
-    }
-
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetMaxMmsSizeL
-// Get maximum MMS message size
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::MaxMmsSizeInBytesL() 
-    {    
-	const TUint32 KCCorMaxMms          = 0x00000006;
-    
-    TInt maxSize = 0;
-      
-    CRepository* mmsRepository = CRepository::NewLC( KCRUidMmsEngine );
-    User::LeaveIfError( mmsRepository->Get( 
-        KMmsEngineMaximumSendSize, maxSize ) );
-
-    if ( !maxSize )
-        {
-        CRepository *repository = CRepository::NewLC( KCRUidCamcorderFeatures );
-        
-        // Maximum MMS size not defined in Camcorder local variation
-        // ini file, try the MMS ini file        
-       	User::LeaveIfError( repository->Get(
-                                KCCorMaxMms, 
-                                maxSize ) ); 
-                                
-        CleanupStack::PopAndDestroy( repository );                        
-        }
-       
-    const TInt KKiloByte = 1024;
-    // How many bytes to allocate for other things than 
-    // video in a MMS message
-    const TInt KMmsSizeReserve = 5 * KKiloByte; 
-    
-    // Convert to kilobytes, leave some space for other things
-    maxSize = Max( maxSize - KMmsSizeReserve, 0 );
-    
-    
-
-    //delete mmsRepository;
-    CleanupStack::PopAndDestroy( mmsRepository ); 
-    return maxSize;
-    }
-
-// ---------------------------------------------------------------------------
-// CcorUtility::CompareIgnoreCase
-// Compare two descriptors
-// ---------------------------------------------------------------------------
-//
-TBool CamUtility::CompareIgnoreCase( const TDesC& aFirst, 
-                                      const TDesC& aSecond )
-    {
-    // Get the standard method
-    TCollationMethod m = *Mem::CollationMethodByIndex( 0 );
-    m.iFlags |= TCollationMethod::EFoldCase;
-    m.iFlags |= TCollationMethod::EIgnoreNone;
-
-    // Magic: Collation level 3 is used
-    return aFirst.CompareC( aSecond, 3, &m ) == 0;
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::DeleteVideoL
-// Delete a video clip.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::DeleteVideoL( const TDesC& aFilename )
-    {
-    TInt err = CEikonEnv::Static()->FsSession().Delete( aFilename );
-    if ( err && err != KErrNotFound )
-        {
-        User::Leave( err );
-        }
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::DeleteStillImageL
-// Delete a still image.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::DeleteStillImageL( const TDesC& aFilename )
-    {
-    TInt err = CEikonEnv::Static()->FsSession().Delete( aFilename );
-    if ( err && err != KErrNotFound )
-        {
-        User::Leave( err );
-        }
-
-    TFileName thumbnailPath;
-    GetThumbnailPath( aFilename, thumbnailPath );
-
-    // ignore error
-    CEikonEnv::Static()->FsSession().Delete( thumbnailPath );
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetThumbnailPath
-// Get full path to a thumbnail file corresponding to given image file.
-// ---------------------------------------------------------------------------
-void CamUtility::GetThumbnailPath( const TDesC& aImagePath, 
-                                    TDes& aThumbnailPath )
-    {
-    TParsePtrC parse( aImagePath );
-    aThumbnailPath = parse.DriveAndPath();
-    aThumbnailPath.Append( PathInfo::ImagesThumbnailPath() );
-    aThumbnailPath.Append( parse.NameAndExt() );
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::RenameStillImageL
-// Rename a still image file.
-// ---------------------------------------------------------------------------
-//
-void CamUtility::RenameStillImageL( const TDesC& aOldPath,
-                                      const TDesC& aNewName,
-                                      TDes& aNewPath )
-    {
-    CFileMan* fileMan = CFileMan::NewL( CEikonEnv::Static()->FsSession() );
-    CleanupStack::PushL( fileMan );
-
-    TParsePtrC parse( aOldPath );
-    TFileName fullNewPath;
-    fullNewPath = parse.DriveAndPath();
-    fullNewPath.Append( aNewName );
-    fullNewPath.Append( parse.Ext() );
-
-    // Rename image file
-    User::LeaveIfError( fileMan->Rename( aOldPath, fullNewPath, 0 ) );
-    // NOTE: flags = 0 --> attempting overwrite will leave
-
-    aNewPath = fullNewPath;
-
-    // Rename thumbnail
-    TFileName oldThumbPath;
-    TFileName newThumbPath;
-    GetThumbnailPath( aOldPath, oldThumbPath );
-    GetThumbnailPath( aNewPath, newThumbPath );
-
-    // ignore error
-    fileMan->Rename( oldThumbPath, newThumbPath, CFileMan::EOverWrite );
-
-    CleanupStack::PopAndDestroy(); // fileMan
-    }
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::IdMatchesName
-// Checks whether the window ID corresponds to the ground name supplied.
-// -----------------------------------------------------------------------------
-//
-TBool CamUtility::IdMatchesName( TInt aWindowId, const TDesC& aWindowGroupName )
-    {   
-    PRINT2(_L("Camera => CamUtility::IdMatchesName ( %d, %S )"), aWindowId, &aWindowGroupName );
-
-	const TInt KMaxWGName = 256;
-	
-    TBuf <KMaxWGName> name;
-
-    // Look up the window group name from the supplied ID.
-    CEikonEnv::Static()->WsSession().GetWindowGroupNameFromIdentifier( aWindowId, name );
-
-    // We have to do some manipulation, as the window group name string
-    // contains NULL seperators which will stop a normal descriptor Find 
-    // operation from finding the string needed.    
-    for ( TInt i=0; i<name.Length(); i++)   // Replace any "null" chars with space
-        {
-        if ( name[i] == NULL )
-            {
-            name[i] = ' ';
-            }
-        }
-        
-    PRINT1(_L("Camera    CamUtility::IdMatchesName tidied name '%S'"), &name);
-                
-    TInt ret = name.Find( aWindowGroupName );
-    
-    PRINT2(_L("Camera    CamUtility::IdMatchesName ret=%d, return(%d)"), ret, ret != KErrNotFound);
-    return ( ret != KErrNotFound );
-    }
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::IsBatteryPowerOK
-// Returns ETrue if the battery power is good
-// -----------------------------------------------------------------------------
-//
-TBool CamUtility::IsBatteryPowerOK()
-	{
-    PRINT(_L("Camera => CamUtility::IsBatteryPowerOK"));
-	TBool isBatteryOK =  EFalse;    // Default to battery low
-
-	TInt strength = EBatteryStatusUnknown;
-	TInt result = RProperty::Get( KPSUidHWRMPowerState, KHWRMBatteryStatus, strength );
-    PRINT2(_L("Camera    CamUtility::IsBatteryPowerOK result=%d, strength=%d"), result, strength);
-	if ( result == KErrNone && strength == EBatteryStatusOk )
-		{
-		isBatteryOK = ETrue;
-		}
-
-    PRINT1(_L("Camera <= CamUtility::IsBatteryPowerOK return(%d)"), isBatteryOK);
-	return isBatteryOK;
-	}
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::IsBatteryPowerEmpty
-// Returns ETrue if the battery power is empty
-// -----------------------------------------------------------------------------
-//
-TBool CamUtility::IsBatteryPowerEmpty()
-    {
-    PRINT(_L("Camera => CamUtility::IsBatteryPowerEmpty"));
-    TBool isBatteryEmpty =  EFalse;    
-
-    TInt strength = EBatteryStatusUnknown;
-    TInt result = RProperty::Get( KPSUidHWRMPowerState, KHWRMBatteryStatus, strength );
-    PRINT2(_L("Camera    CamUtility::IsBatteryPowerEmpty result=%d, strength=%d"), result, strength);
-    if ( result == KErrNone && strength == EBatteryStatusEmpty )
-        {
-        isBatteryEmpty = ETrue;
-        }
-
-    PRINT1(_L("Camera <= CamUtility::IsBatteryPowerEmpty return(%d)"), isBatteryEmpty);
-    return isBatteryEmpty;
-    }
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::IsBatteryCharging
-// Returns ETrue if the battery is being charged
-// -----------------------------------------------------------------------------
-//
-TBool CamUtility::IsBatteryCharging()
-	{
-    PRINT(_L("Camera => CamUtility::IsBatteryCharging"));
-	TBool isCharging = EFalse;      // Default to not charging
-
-	TInt charge = EChargingStatusError;
-	TInt result = RProperty::Get( KPSUidHWRMPowerState, KHWRMChargingStatus, charge );
-    PRINT2(_L("Camera    CamUtility::IsBatteryCharging result=%d, charge=%d"), result, charge);
-	if ( (result == KErrNone) && (charge == EChargingStatusCharging || 
-								  charge == EChargingStatusAlmostComplete || 
-								  charge == EChargingStatusChargingContinued || 
-								  charge == EChargingStatusChargingComplete) )
-		{
-		isCharging = ETrue;
-		}
-    PRINT1(_L("Camera <= CamUtility::IsBatteryCharging return(%d)"), isCharging);
-
-	return isCharging;
-	}
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::IsLocationAware()
-// Returns ETrue if LocationTrail is started and valid GPS data is available
-// -----------------------------------------------------------------------------
-//
-TBool CamUtility::IsLocationAware()
-    {
-#ifndef __WINSCW__
-    TBool ret = EFalse;
-    TInt keyVal;
-    TInt err = RProperty::Get( KPSUidLocationTrail, KLocationTrailState, keyVal );
-    if( KErrNone == err )
-        {
-        if( KCamLocationTrailGPSDataAvail == keyVal )
-            {
-            ret = ETrue;
-            }    
-        }
-    return ret;
-#else
-    return ETrue;
-#endif // !__WINSCW__
-    }
-
-// ---------------------------------------------------------
-// CamUtility::SetAlphaL  
-// ---------------------------------------------------------
-//
-void CamUtility::SetAlphaL( CFbsBitmap*& aBmp, CFbsBitmap*& aMask, 
-                            TRgb aColor ) 
-    {
-    // Draw EColor16MA bitmap: 
-    CFbsBitmap* bmpWithAlpha = new (ELeave) CFbsBitmap();
-	User::LeaveIfError( 
-	                 bmpWithAlpha->Create( aBmp->SizeInPixels(), EColor16MA) );  
-	CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( bmpWithAlpha );
-    CleanupStack::PushL( device );
-    CFbsBitGc* gc;
-    User::LeaveIfError( device->CreateContext(gc) );
-    CleanupStack::PushL(gc);
-	
-    gc->BitBlt( TPoint(0,0), aBmp );
-    delete aBmp; 
-    aBmp = NULL;
-    aBmp = bmpWithAlpha;
-    
-    CleanupStack::PopAndDestroy(gc);
-    CleanupStack::PopAndDestroy(device);
-
-    // Ensure mask colour depth
-    TSize size = aMask->SizeInPixels();
-    TBool inv( EFalse );
-    if ( aMask->DisplayMode() != EGray256 ) 
-        {
-        CFbsBitmap* bmp256 = new (ELeave) CFbsBitmap();
-        User::LeaveIfError( 
-	                 bmp256->Create( size, EGray256) ); 
-	    CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( bmp256 );
-        CleanupStack::PushL( device );
-        CFbsBitGc* gc;
-        User::LeaveIfError( device->CreateContext(gc) );
-        CleanupStack::PushL(gc); 
-        gc->BitBlt( TPoint(0,0), aMask );
-        delete aMask; 
-        aMask = NULL;
-        aMask = bmp256;  
-        CleanupStack::PopAndDestroy(gc);
-        CleanupStack::PopAndDestroy(device); 
-        inv = ETrue;          
-        }
-           
-    // Add Alpha values:    
-    TUint32 dPitch = CFbsBitmap::ScanLineLength( size.iWidth, EColor16MA ) / 4;
-    TUint32 maskPitch = CFbsBitmap::ScanLineLength( size.iWidth, EGray256 );                     
-    aMask->LockHeap();
-    aBmp->LockHeap();
-
-    // Component is not expected to deal with the extended bitmap. 
-    TUint32* destAddr = reinterpret_cast<TUint32*>( aBmp->DataAddress() );
-        
-    for ( TUint32 y = 0; y < size.iHeight; y++ )
-        {
-        HBufC8* maskBuf = HBufC8::NewLC( maskPitch );
-        TPtr8 maskPtr = maskBuf->Des();
-        aMask->GetScanLine( maskPtr, TPoint(0, y), size.iWidth, EGray256 );
-        for ( TUint32 x = 0; x < size.iWidth; x++ )
-            {
-            TUint8 value = maskPtr[x];
-            if ( inv )
-                {
-                value = ~value;
-                }
-            // Round mask value to fully opaque or transparent
-            if ( value > 0x7f ) 
-                {
-                // Opaque pixel.
-                destAddr[ y * dPitch + x ] &= aColor.Internal();  
-                destAddr[ y * dPitch + x ] |= 0xFF000000;
-                }
-            else
-                {
-                // Transparent pixel
-                destAddr[ y * dPitch + x ] = 0x00000000;
-                }
-            }
-        CleanupStack::PopAndDestroy(maskBuf);
-        }
-        
-    aBmp->UnlockHeap();
-    aMask->UnlockHeap();
-    
-    // Mask is not used for drawing
-    delete aMask;
-    aMask = NULL;
-    }
-
-// ---------------------------------------------------------
-// CamUtility::IsUsbActive
-// ---------------------------------------------------------
-//        
-TBool CamUtility::IsUsbActive()
-    {
-    TInt usbState;
-    TInt err = RProperty::Get( KPSUidCoreApplicationUIs,
-                               KCoreAppUIsUSBFileTransfer,
-                               usbState );                                  
-    return !err && usbState == ECoreAppUIsUSBFileTransferActive;
-    }
-    
-// ---------------------------------------------------------
-// CamUtility::IsNhdDevice for Layouts only
-// ---------------------------------------------------------
-//        
-TBool CamUtility::IsNhdDevice() 
-    {
-    TRect screenRect;
-    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );   
-    TRect nhdRectLandscape( TSize( KCamNhdWidth, KCamNhdHeight ) );
-    TRect nhdRectPortrait( TSize( KCamNhdHeight, KCamNhdWidth ) ); 
- 
-    return screenRect == nhdRectLandscape || screenRect == nhdRectPortrait;
-    }
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetPsiInt
-// Allows retrieval of product specific information (TInt)
-// ---------------------------------------------------------------------------
-//
-#ifndef CAMERAAPP_PLUGIN_BUILD
-
-TInt CamUtility::GetPsiInt( TCamPsiKey aKey, TInt& aValue )
-  {
-  aValue = KErrNotSupported;
-
-  switch ( aKey )
-    {
-    case ECamPsiOrientation:
-    case ECamPsiPrimaryCameraOrientation:
-    case ECamPsiSecondaryCameraOrientation:
-    case ECamPsiEditingOrientation:
-         return CamUtility::GetCommonPsiInt( aKey, aValue );
-    case ECamPsiOverLaySidePane:  { aValue = ETrue;         break; }
-    case ECamPsiSidePanePosition: { aValue = ECamHandRight; break; }
-    case ECamPsiSoftKeyPosition:  { aValue = ECamHandRight; break; } 
-
-    case ECamPsiLeftNaviKey:     { aValue = ECamNaviKeyCaptureSetup; break; }
-    case ECamPsiLeftNaviKeyCam2: { aValue = ECamNaviKeyNone;         break; }
-    case ECamPsiRightNaviKey:    { aValue = ECamNaviKeyNone;         break; }
-    case ECamPsiVideoZoomSupport:    { aValue = ECamZoomWhenRecord; break; }
-
-
-     // Interval: return the value in units of 1000 microseconds
-    case ECamPsiLongCaptureKeyPressInterval: { aValue = KCaptureLongPress;            break; }
-    case ECamPsiMaxBurstCapture:             { aValue = KMaxBurstImages;              break; }
-    case ECamPsiCourtesyUiTimeoutValue:      { aValue = KCourtesyUiTimeoutValue;      break; } 
-    case ECamPsiAPEVCompLegend:                { aValue = R_CAM_CAPTURE_SETUP_MENU_PHOTO_EXPOSURE_ARRAY2; break; }
-    default:
-      {
-      return KErrNotSupported;
-      }
-    }
-  return KErrNone;
-  }
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetPsiIntArrayL
-// Allows retrieval of product specific information (TInt array)
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::GetPsiIntArrayL( TCamPsiKey aKey, RArray<TInt>& aArray )
-  {
-  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
-  CCameraUiConfigManager* configManager = appUi->AppController().UiConfigManagerPtr();
-
-  switch ( aKey )
-    {     
-    // Resource ids for User Scene setup items  
-    case ECamPsiUserSceneResourceIds:
-      {
-      User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_SCENEBASE_DATA    ) );
-      if ( configManager->IsFlashModeSupported() )
-          User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_FLASH_DATA ) );
-      if ( configManager->IsWhiteBalanceFeatureSupported() )
-          User::LeaveIfError( aArray.Append( 
-                                    R_CAM_PHOTO_USER_SCENE_SETUP_LIST_WHITEBALANCE_DATA ) );
-      if ( configManager->IsEVSupported() )
-          User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_EV_DATA2 ) );
-
-      if ( configManager->IsColorToneFeatureSupported() )
-          User::LeaveIfError( aArray.Append( 
-                                    R_CAM_PHOTO_USER_SCENE_SETUP_LIST_COLOUREFFECT_DATA ) );
-      if ( configManager->IsISOSupported() )
-        {
-        if ( configManager->IsExtendedLightSensitivitySupported() ) 
-            {
-            User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_EXTENDED_LIGHTSENSITIVITY_DATA ) );
-            } 
-       else {
-            User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_LIGHTSENSITIVITY_DATA ) );
-            }
-        }
-      
-      if ( configManager->IsSharpnessFeatureSupported() )
-          User::LeaveIfError( aArray.Append( 
-                                    R_CAM_PHOTO_USER_SCENE_SETUP_LIST_IMAGESHARPNESS_DATA ) );
-      
-      if ( configManager->IsContrastSupported() )
-          User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_CONTRAST_DATA ) );
-
-      User::LeaveIfError( aArray.Append( R_CAM_PHOTO_USER_SCENE_SETUP_LIST_RESET_DATA        ) );
-      break;
-      }
-    // -----------------------------------------------------
-    default:
-      {
-      return KErrNotSupported;
-      }
-    }
-  return KErrNone;
-  }
-
-// ---------------------------------------------------------------------------
-// CamUtility::GetPsiAnyL
-// Allows retrieval of product specific information (TAny)
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::GetPsiAnyL( TCamPsiKey aKey, TAny* aValue )
-  {
-  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
-  CCameraUiConfigManager* uiConfigManager = appUi->AppController().UiConfigManagerPtr();
-
-  RArray<TInt> zoomValues;
-  CleanupClosePushL( zoomValues );
-  zoomValues.Reset();
-  
-  typedef TPckgBuf<TCamMaxZoomSteps>          TCamZoomStepPckg;
-  typedef TPckgBuf<TSelfTimerSetting>         TCamTimerSetPckg;
-  typedef TPckgBuf<TCamZoomLAF>               TCamZoomLAFPckg;
-  typedef TPckgBuf<TCamEvCompRange>           TCamEVCompPckg;
-
-  switch ( aKey )
-    {
-    // -----------------------------------------------------
-    // Self timer periods
-    case ECamPsiSelfTimerPeriod1:
-      {
-      // Default constructor assigns KErrNotSupported to all fields.
-      // See CamPSI.h.
-      TSelfTimerSetting timerPeriod1; 
-
-      // First period is at 2-seconds remaining, "always on"
-      timerPeriod1.iThreshold  [0] = 2*KMicroSecPerSec;
-      timerPeriod1.iFlashPeriod[0] = KMaxTInt;
-      timerPeriod1.iBeepPeriod [0] = KMaxTInt;
-
-      // There are no other periods
-
-      // Autofocus triggered on "2-seconds remaining"
-      timerPeriod1.iAutoFocus = 2*KMicroSecPerSec;
-
-      TCamTimerSetPckg* ptr = static_cast<TCamTimerSetPckg*>( aValue );
-      *ptr = timerPeriod1;
-      break;
-      }
-    case ECamPsiSelfTimerPeriod2:
-      {
-      TSelfTimerSetting timerPeriod2;
-       
-      // First period is at 10-seconds until capture, flashing once every second.
-      timerPeriod2.iThreshold  [0] = 10*KMicroSecPerSec;
-      timerPeriod2.iFlashPeriod[0] = KMicSecInHalfSec;   // 500ms on/500ms off
-      timerPeriod2.iBeepPeriod [0] = KMicroSecPerSec;       // Beep every second
-
-      // Second period starts at 3-seconds until capture, flashing twice every second
-      timerPeriod2.iThreshold  [1] = 5*KMicroSecPerSec;
-      timerPeriod2.iFlashPeriod[1] = KMicSecInQuartSec;  // 250ms on/250ms off
-      timerPeriod2.iBeepPeriod [1] = KMicSecInHalfSec;   // Beep twice every second
-
-      // Third period is not supported
-      timerPeriod2.iThreshold  [2] = 3*KMicroSecPerSec;
-      timerPeriod2.iFlashPeriod[2] = KMaxTInt;
-      timerPeriod2.iBeepPeriod [2] = KMaxTInt;
-
-      // Autofocus triggered on "3-seconds remaining"
-      timerPeriod2.iAutoFocus = 3*KMicroSecPerSec;          
-
-      TCamTimerSetPckg* ptr = static_cast<TCamTimerSetPckg*>( aValue );
-      *ptr = timerPeriod2;
-      break;
-      }
-    case ECamPsiSelfTimerPeriod3:
-      {
-      TSelfTimerSetting timerPeriod3;
-
-      // First period is at 20-seconds until capture, flashing once every second.
-      timerPeriod3.iThreshold  [0] = 20*KMicroSecPerSec;
-      timerPeriod3.iFlashPeriod[0] = KMicSecInHalfSec;   // 500ms on/500ms off
-      timerPeriod3.iBeepPeriod [0] = KMicroSecPerSec;       // Beep every second
-
-      // Second period starts at 3-seconds until capture, flashing twice every second
-      timerPeriod3.iThreshold  [1] = 5*KMicroSecPerSec;
-      timerPeriod3.iFlashPeriod[1] = KMicSecInQuartSec;  // 250ms on/250ms off
-      timerPeriod3.iBeepPeriod [1] = KMicSecInHalfSec;   // Beep twice every second
-
-      // Third period is not supported
-      timerPeriod3.iThreshold  [2] = 3*KMicroSecPerSec;
-      timerPeriod3.iFlashPeriod[2] = KMaxTInt;
-      timerPeriod3.iBeepPeriod [2] = KMaxTInt;
-
-      // Autofocus triggered on "3-seconds remaining"
-      timerPeriod3.iAutoFocus = 3*KMicroSecPerSec;
-
-      TCamTimerSetPckg* ptr = static_cast<TCamTimerSetPckg*>( aValue );
-      *ptr = timerPeriod3;
-      break;
-      }
-    // -----------------------------------------------------
-    // Zoom steps.
-    case ECamPsiMaxOpticalZoomSteps:
-      {
-      // Default constructor defined to initialize
-      // all fields to KErrNotSupported. See CamPSI.h.
-      TCamMaxZoomSteps optSteps;
-
-      // No optical zoom steps supported => nothing more to set.
-
-      TCamZoomStepPckg* ptr = static_cast<TCamZoomStepPckg*>( aValue );
-      *ptr = optSteps;
-      break;
-      }
-    case ECamPsiMaxZoomSteps:
-      {
-      TCamMaxZoomSteps digSteps;
-      
-      // the order the values read are exactly in the order defined in
-      // TCamMaxZoomSteps
-      
-      uiConfigManager->SupportedMaxZoomStepsL( zoomValues );
-      
-      // all the values if they are supported or not will be run-time
-      TInt count = zoomValues.Count()-1; 
-      TInt i = 0;
-      if ( zoomValues.Count() )   
-          {
-          digSteps.iMaxPhotoStepW9MP        = zoomValues[Min(count,i++)]; 
-          digSteps.iMaxPhotoStepW6MP        = zoomValues[Min(count,i++)]; 
-          digSteps.iMaxPhotoStep12MP        = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep8MP         = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep5MP         = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep3MP         = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep2MP         = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep1_3MP       = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep1MP         = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStep0_8MP       = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStepSVGA        = zoomValues[Min(count,i++)];
-          digSteps.iMaxPhotoStepVGA         = zoomValues[Min(count,i++)];
-
-          
-          digSteps.iMaxVideoStepHD          = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepWVGA        = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepNHD         = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepVGA         = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepQVGA        = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepCIF         = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepQCIF        = zoomValues[Min(count,i++)];
-          digSteps.iMaxVideoStepSQCIF       = zoomValues[Min(count,i++)];
-          digSteps.iMax2ndCamPhotoStep      = zoomValues[Min(count,i++)];
-          digSteps.iMax2ndCamVideoStepCIF   = zoomValues[Min(count,i++)];
-          digSteps.iMax2ndCamVideoStepQCIF  = zoomValues[Min(count,i++)];
-          digSteps.iMax2ndCamVideoStepSQCIF = zoomValues[Min(count,i++)];
-          }
-      else
-          {
-          User::Leave( KErrNotSupported );
-          }
-      TCamZoomStepPckg* ptr = static_cast<TCamZoomStepPckg*>( aValue );
-      *ptr = digSteps;
-      break;
-      }
-    case ECamPsiMaxExtendedZoomSteps:
-      {
-      TCamMaxZoomSteps extSteps;
-
-      // the order the values read are exactly in the order defined in
-      // TCamMaxZoomSteps
-
-      uiConfigManager->SupportedMaxExtendedZoomStepsL( zoomValues );
-      
-      // TODO: some kind of check to see if there are all possible values in
-      //       the array that we ask from config manager.
-      TInt count = zoomValues.Count()-1; 
-      TInt i = 0;
-      if ( zoomValues.Count() > 0 )
-          {
-          extSteps.iMaxPhotoStepW9MP   = zoomValues[Min(count,i++)]; 
-          extSteps.iMaxPhotoStepW6MP   = zoomValues[Min(count,i++)]; 
-          extSteps.iMaxPhotoStep12MP   = zoomValues[Min(count,i++)]; //KMaxPhoto12MPExtZoomStep;  
-          extSteps.iMaxPhotoStep8MP    = zoomValues[Min(count,i++)]; //KMaxPhoto8MPExtZoomStep;  
-          extSteps.iMaxPhotoStep5MP    = zoomValues[Min(count,i++)]; //KMaxPhoto5MPExtZoomStep;
-          extSteps.iMaxPhotoStep3MP    = zoomValues[Min(count,i++)]; //KMaxPhoto3MPExtZoomStep;
-          extSteps.iMaxPhotoStep2MP    = zoomValues[Min(count,i++)]; //KMaxPhoto2MPExtZoomStep;
-          extSteps.iMaxPhotoStep1_3MP  = zoomValues[Min(count,i++)]; //KMaxPhoto1_3MPExtZoomStep;
-          extSteps.iMaxPhotoStep1MP    = zoomValues[Min(count,i++)]; //KMaxPhoto1MPExtZoomStep;
-          extSteps.iMaxPhotoStep0_8MP  = zoomValues[Min(count,i++)]; //KMaxPhoto0_8MPExtZoomStep;
-          extSteps.iMaxPhotoStepSVGA   = zoomValues[Min(count,i++)];          
-          extSteps.iMaxPhotoStepVGA    = zoomValues[Min(count,i++)]; //KMaxPhotoVGAExtZoomStep;
-          }
-      else
-          {
-          User::Leave( KErrNotSupported );
-          }
-      TCamZoomStepPckg* ptr = static_cast<TCamZoomStepPckg*>( aValue );
-      *ptr = extSteps;
-      break;
-      }
-    // -----------------------------------------------------
-    // Zoom appearance
-    case ECamPsiZoomBarLAF:
-      {
-      const TRgb KZoomColourDig = TRgb( 255, 140, 1 );
-      const TRgb KZoomColourExt = TRgb( 255, 0, 0 );
-
-      TCamZoomLAF zoomLAF;
-      uiConfigManager->SupportedLAFZoomBarL( zoomValues );
-      
-      if ( zoomValues.Count() > 0 )
-          {
-          // Time per zoom tick in milliseconds
-          zoomLAF.iZoomSpeedDig  = zoomValues[0]; //KZoomSpeedDig;
-          // No of zoom steps per tick
-          zoomLAF.iZoomStepsDig  = zoomValues[2]; //KZoomStepsDig;
-
-          // Time per ext zoom tick in milliseconds
-          zoomLAF.iZoomSpeedExt  = zoomValues[1]; //KZoomSpeedExt;
-          // No of ext zoom steps per tick  
-          zoomLAF.iZoomStepsExt  = zoomValues[3]; //KZoomStepsExt;
-          
-          zoomLAF.iSecondCameraZoomSteps = zoomValues[4]; //K2ndCamZoomStepSize
-          }
-      else
-          {
-          User::Leave( KErrNotSupported );
-          }
-      
-      // Colour of optical zoom in zoom bar
-      zoomLAF.iZoomColourDig = KZoomColourDig;
-      // Colour of optical zoom in zoom bar
-      zoomLAF.iZoomColourExt = KZoomColourExt;                
-
-      TCamZoomLAFPckg* ptr = static_cast<TCamZoomLAFPckg*>( aValue );
-      *ptr = zoomLAF;
-      break;
-      }
-    // -----------------------------------------------------
-    // Exposure compensation values
-    case ECamPsiEVCompSliderInfo:
-      {
-      TCamEvCompRange evComp;
-
-      evComp.iMinValue     = KEVCompMinVal;
-      evComp.iMaxValue     = KEVCompMaxVal;
-      evComp.iStepsPerUnit = KEVCompStepsPerUnit;
-
-      TCamEVCompPckg* ptr = static_cast<TCamEVCompPckg*>( aValue );
-      *ptr = evComp;
-      break;
-      }
-    // -----------------------------------------------------
-    default:
-      {
-      return KErrNotSupported;        
-      }
-    // -----------------------------------------------------
-    }
-  CleanupStack::PopAndDestroy( &zoomValues );
-  return KErrNone;
-  }
-
-    
-// ---------------------------------------------------------------------------
-// CamUtility::ResourceOrientationID
-// Returns the resource for the given ID, based on the current Orientation
-// ---------------------------------------------------------------------------
-//
-TInt 
-CamUtility::ResourceOrientationID( TInt aDefaultResourceID )
-  {
-  TCamOrientation orientation;
-  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
-
-  // Make sure the resource ID is in a valid range
-  TBool inValidRange = Rng( 0, aDefaultResourceID, R_CAM_LAST_RESOURCE_ID );
-  __ASSERT_DEBUG( inValidRange, CamPanic(ECamPanicInvalidResource) );
-
-  // This should never happen, but we may be being passed the original resource number
-  if( !inValidRange ) { return aDefaultResourceID; }
-
-  // Get the current orientation
-  // If we don't have the AppUI, 
-  // assume the app is starting up and use the default orientation
-  if( appUi ) { orientation = appUi->CamOrientation(); }
-  else        { orientation = ECamOrientationDefault;  }
-
-  __ASSERT_DEBUG( (ECamOrientationTotal > orientation), CamPanic(ECamPanicBadIndex) );
-      
-  return KRoidLookup[aDefaultResourceID][orientation];
-  }
-
-
-// ---------------------------------------------------------------------------
-// MapLightSensitivity2IsoValueL
-// Maps each general light sensitivity id (TCamLightSensitivityId)
-// to a product specific ISO rating.
-// ---------------------------------------------------------------------------
-//
-TInt
-CamUtility::MapLightSensitivity2IsoValueL( TCamLightSensitivityId aLightSensitivityId, RArray<TInt>& aSupportedValues )
-  {
-    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
-    CCameraUiConfigManager* UiConfigManager = appUi->AppController().UiConfigManagerPtr();
-    
-    aSupportedValues.Sort();
-    TInt count = aSupportedValues.Count();
-    if ( count == 0 )
-        {
-        return ECamIsoRateAuto;
-        }
-    if ( UiConfigManager->IsExtendedLightSensitivitySupported() )
-        {
-        // Make sure there is enough supported ISO values for extended light sensitivity
-        // first value is 0 which means automatic, there should be 5 or more other values
-        TBool enoughSupported = (count > 5);
-        if ( !enoughSupported ) {
-            CamPanic(ECamPanicNotEnoughISOValuesSupported);
-        }
-        switch ( aLightSensitivityId )
-            {
-            // Supports: 100, 200, 400, 800, 1600, 3200.
-            case ECamLightSensitivityLow:       return aSupportedValues[1];
-            case ECamLightSensitivityLowMed:    return aSupportedValues[2];
-            case ECamLightSensitivityMed:       return aSupportedValues[3];
-            case ECamLightSensitivityMedHigh:   return aSupportedValues[4];
-            case ECamLightSensitivityHigh:      return aSupportedValues[5];
-            default:                            return ECamIsoRateAuto;
-            }
-        }
-    else 
-        {
-        switch ( aLightSensitivityId )
-            {
-            case ECamLightSensitivityLow:       return aSupportedValues[0];
-            case ECamLightSensitivityMed:       return aSupportedValues[TInt(count/2)];
-            case ECamLightSensitivityHigh:      return aSupportedValues[count-1];
-            default:                            return ECamIsoRateAuto;
-            }
-        }
-  }
-
-
-// ---------------------------------------------------------------------------
-// MapSharpnessId2SharpnessValueL
-// Maps each general sharpness value (TCamImageSharpnessId)
-// to a product specific value.
-// ---------------------------------------------------------------------------
-//
-TInt 
-CamUtility::MapSharpnessId2SharpnessValueL( TCamImageSharpnessId aSharpnessId )
-  {
-  TInt sharpnessValue = 0;
-  RArray<TInt> supportedValues;
-  CleanupClosePushL( supportedValues );
-  
-  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
-  if ( appUi && appUi->AppController().UiConfigManagerPtr() )
-      {
-      appUi->AppController().UiConfigManagerPtr()->SupportedSharpnessSettingsL( 
-                                                               supportedValues );
-      }
-  
-  if ( supportedValues.Count() > 0 )
-      {
-      switch( aSharpnessId )
-        {
-        case ECamImageSharpnessHard:    
-            sharpnessValue = supportedValues[supportedValues.Count()-1];
-            break;
-        case ECamImageSharpnessSoft:
-            sharpnessValue =  supportedValues[0];
-            break;
-        case ECamImageSharpnessNorm:    // <<fall through>>
-        default:
-            sharpnessValue = supportedValues[1]; // normal value = 0
-            break;
-      }
-     }
-  else
-      {
-      User::Leave( KErrNotSupported );
-      }
-   CleanupStack::PopAndDestroy( &supportedValues );
-
-   return sharpnessValue;
-  }
-
-
-// ---------------------------------------------------------------------------    
-// CamUtility::MapVideoQualityToViewFinderRes
-// Return resource id for viewfinder resolution for primary camera
-// ---------------------------------------------------------------------------
-//    
-TInt 
-CamUtility::MapVideoQualityToViewFinderRes( TCamVideoResolution aResolution )
-  {
-  PRINT1( _L("Camera => CamUtility::MapVideoQualityToViewFinderRes res (%d)"), aResolution )
-  switch( aResolution )
-    {
-    case ECamVideoResolutionVGA: return R_CAM_VIEWFINDER_RECT_QVGA_CAMCORDER;
-    case ECamVideoResolutionQVGA: return R_CAM_VIEWFINDER_RECT_QVGA_CAMCORDER;
-    case ECamVideoResolutionQCIF: return R_CAM_VIEWFINDER_RECT_CIF_CAMCORDER_ADJUSTED;
-    default:                      return R_CAM_VIEWFINDER_RECT_QVGA_CAMCORDER;
-    }
-  }
-
-#endif // CAMERAAPP_PLUGIN_BUILD
-// ---------------------------------------------------------------------------
-// CamUtility::GetCommonPsiInt
-// Allows retrieval of product specific information (TInt)
-// ---------------------------------------------------------------------------
-//
-TInt CamUtility::GetCommonPsiInt( TCamPsiKey aKey, TInt& aValue )
-  {
-  aValue = KErrNotSupported;
-
-  switch ( aKey )
-    {
-    case ECamPsiOrientation:                { aValue = CAknAppUiBase::EAppUiOrientationLandscape; break; }
-    case ECamPsiPrimaryCameraOrientation:   { aValue = CAknAppUiBase::EAppUiOrientationLandscape; break; }
-    case ECamPsiSecondaryCameraOrientation: { aValue = CAknAppUiBase::EAppUiOrientationPortrait;  break; }
-    case ECamPsiEditingOrientation:         { aValue = CAknAppUiBase::EAppUiOrientationPortrait;  break; }               
-
-    default:
-      {
-      return KErrNotSupported;
-      }
-    }
-  return KErrNone;
-  }
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::IsQwertyOpen
-// -----------------------------------------------------------------------------
-//
-TBool CamUtility::IsQwertyOpen()
-	{
-    TBool retvalue = EFalse;    
-    TInt status = 0;
-    TInt err = RProperty::Get( KCRUidAvkon, KAknQwertyInputModeActive, status );
-    PRINT2(_L("Camera <> CamUtility::IsQwertyOpen err%d status%d"),err, status);
-	if ( !err && status )
-        {
-		retvalue = ETrue;
-		}    
-    return retvalue;
-	}
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::ViewfinderLayout
-//
-// Get resolution from CCamAppController::GetCurrentVideoResolution()
-// or CCamAppController::GetCurrentImageResolution().
-//
-// -----------------------------------------------------------------------------
-//
-TRect
-CamUtility::ViewfinderLayout( TCamCameraMode aMode,
-                              TInt           aResolution )
-  {
-  PRINT1( _L("Camera => CamUtility::ViewfinderLayout - resolution[%d]"), aResolution );
-
-  TAknWindowLineLayout l = IsNhdDevice() 
-                         ? ViewfinderLayoutTouch(aMode, aResolution)
-                         : ViewfinderLayoutNonTouch(aMode, aResolution);  
-
-  TRect screenRect;
-  if ( Layout_Meta_Data::IsLandscapeOrientation() || IsNhdDevice() )
-      {
-      AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );
-      }
-  else
-      {
-      AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, screenRect );
-      }
-
-  TAknLayoutRect vfLayoutRect;
-  vfLayoutRect.LayoutRect( screenRect, l );
-  TRect vfRect( vfLayoutRect.Rect() );
-
-  PRINT4( _L("Camera <= CamUtility::ViewfinderLayout - rect[x:%d y:%d w:%d h:%d]"),
-          vfRect.iTl.iX, vfRect.iTl.iY, vfRect.Width(), vfRect.Height() );
-
-  return vfRect;
-  }
-
-
-// -----------------------------------------------------------------------------
-// CamUtility::ViewfinderLayoutTouch
-//
-// -----------------------------------------------------------------------------
-//
-TAknWindowLineLayout 
-CamUtility::ViewfinderLayoutTouch( TCamCameraMode aMode,
-                                   TInt           aResolution )
-  { 
-  TInt variant = Layout_Meta_Data::IsLandscapeOrientation();
-  
-  // Default to 4:3 full screen
-  TAknWindowLineLayout l = 
-      AknLayoutScalable_Apps::cam4_image_uncrop_pane( variant );
-
-  // -------------------------------------------------------      
-  // Video mode
-  if ( ECamControllerVideo == aMode )
-    {
-    switch( aResolution )
-      {
-      case ECamVideoResolutionQCIF:
-      case ECamVideoResolutionCIF:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutTouch - QCIF/CIF video resolution") );
-        l = AknLayoutScalable_Apps::video4_image_uncrop_cif_pane( variant );
-        break;
-        }
-      case ECamVideoResolutionNHD:
-      case ECamVideoResolutionHD:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutTouch - nHD/HD video resolution") );
-        l = AknLayoutScalable_Apps::video4_image_uncrop_nhd_pane( variant );
-        break;
-        }
-      default:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutTouch - 4:3 video resolution") );
-        // All other video resolutions are expected to
-        // have 4:3 aspect ratio
-        l = AknLayoutScalable_Apps::video4_image_uncrop_vga_pane( variant );
-        break;
-        }
-      }
-    }
-  // -------------------------------------------------------      
-  // Image mode
-  else if ( ECamControllerImage == aMode )
-    {
-    switch( aResolution )
-      {
-      case ECamPhotoSizeW9MP:
-      case ECamPhotoSizeW6MP:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutTouch - 16:9 still image resolution") );
-        l = AknLayoutScalable_Apps::video4_image_uncrop_nhd_pane( variant );
-        break;
-        }
-      default:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutTouch - 4:3 still image resolution") );
-        l = AknLayoutScalable_Apps::cam4_image_uncrop_pane( variant );
-        break;
-        }
-      }
-    }
-  // -------------------------------------------------------      
-
-  return l;
-  }
-
-
-
-// ---------------------------------------------------------------------------
-// CamUtility::ViewfinderLayoutNonTouch
-// ---------------------------------------------------------------------------
-//
-TAknWindowLineLayout 
-CamUtility::ViewfinderLayoutNonTouch( TCamCameraMode aMode,
-                                      TInt           aResolution )
-  {
-  TInt variant = Layout_Meta_Data::IsLandscapeOrientation() ? 0 : 3;
-  
-  TAknWindowLineLayout l =
-      AknLayoutScalable_Apps::cam6_image_uncrop_pane( variant );
-
-  // -------------------------------------------------------      
-  // Video mode
-  if ( ECamControllerVideo == aMode )
-    {
-    switch( aResolution )
-      {
-      case ECamVideoResolutionQCIF:
-      case ECamVideoResolutionCIF:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutNonTouch - QCIF/CIF video resolution") );
-        l = AknLayoutScalable_Apps::vid6_image_uncrop_cif_pane( variant );
-        break;
-        }
-      case ECamVideoResolutionNHD:
-      case ECamVideoResolutionHD:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutNonTouch - nHD/HD video resolution") );
-        l = AknLayoutScalable_Apps::vid6_image_uncrop_nhd_pane( variant );
-        break;
-        }
-      case ECamVideoResolutionWVGA:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutNonTouch - WVGA video resolution") );
-        l = AknLayoutScalable_Apps::vid6_image_uncrop_wvga_pane( variant );
-        break;
-        }
-      default:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutNonTouch - 4:3 video resolution") );
-        // All other video resolutions are expected to
-        // have 4:3 aspect ratio
-        l = AknLayoutScalable_Apps::vid6_image_uncrop_vga_pane( variant );
-        break;
-        }
-      }
-    }
-  // -------------------------------------------------------      
-  // Image mode
-  else
-    {
-    switch( aResolution )
-      {
-      case ECamPhotoSizeW9MP:
-      case ECamPhotoSizeW6MP:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutNonTouch - 16:9 still image resolution") );
-        l = AknLayoutScalable_Apps::vid6_image_uncrop_nhd_pane( variant );
-        }
-      default:
-        {
-        PRINT( _L("Camera <> CamUtility::ViewfinderLayoutNonTouch - 4:3 still image resolution") );
-        l = AknLayoutScalable_Apps::cam6_image_uncrop_pane( variant );
-        break;
-        }
-      }
-    }
-  // -------------------------------------------------------      
-
-  return l;
-  }
-
-
-//  End of File  
-