--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/common/src/CamUtility.cpp Wed Sep 01 12:30:54 2010 +0100
@@ -0,0 +1,1709 @@
+/*
+* Copyright (c) 2007-2010 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_SET_USER_DEFAULT ) );
+ 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] = KMicSecInQuartSec;// KMaxTInt;
+ timerPeriod1.iBeepPeriod [0] = KMicSecInHalfSec;// 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] = 2*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] = 0*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] = 2*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] = 0*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
+