/*

* 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.