/*
* Copyright (c) 2006-2008 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:
* An utility class to handle the UIDs and filename extensions used to
* identify data types. It is also used to store the results per data type.
*
*/
// SYSTEM INCLUDES
#include <mseng.rsg>
#include <bautils.h>
#include <barsc.h> // RResourceFile
// USER INCLUDES
#include "msenginfoarray.h"
#include "mseng.h" // KMsengRscFilePath
// ================= MEMBER FUNCTIONS =======================
// ---------------------------------------------------------------------------
// CMsengInfoArray::CMsengInfoArray()
//
// C++ default constructor is prohibited
// ---------------------------------------------------------------------------
CMsengInfoArray::CMsengInfoArray(TDriveNumber aDrive)
: iCurrentScannedDrive(aDrive)
{
}
// ---------------------------------------------------------------------------
// CMsengInfoArray::NewL()
//
// Two-phased constructor.
// ---------------------------------------------------------------------------
CMsengInfoArray* CMsengInfoArray::NewL(TDriveNumber aDrive,
TInt aNumberOfDataGroups,
RFs& aFsSession,
CResourceFile& aResFile)
{
CMsengInfoArray* self = new (ELeave) CMsengInfoArray(aDrive);
CleanupStack::PushL( self );
self->ConstructL(aNumberOfDataGroups, aFsSession, aResFile);
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CMsengInfoArray::ConstructL()
//
// Symbian OS default constructor can leave.
// ---------------------------------------------------------------------------
void CMsengInfoArray::ConstructL(TInt aNumberOfDataGroups,
RFs& aFsSession,
CResourceFile& aResFile)
{
// Create data structures and initialize them
// using values from enumerations TUidTypes and TExtTypes
// and data from the resource file mseng.rss
TInt index = -1; // index used in for-loops
TInt length = -1; // length of resource array being read
RResourceReader theReader;
theReader.OpenLC( &aResFile, UIDARRAY );
//the first WORD contains the number of elements in the resource
length = theReader.ReadInt16L();
// Create the array with appropriate granularity
iUidResultArray = new (ELeave) CArrayFixFlat<TInt64>(length);
// Initialize the array to contain zeros
for(index=0; index<length; index++)
{
iUidResultArray->InsertL(index, 0);
}
// Next, create the array for the actual UIDs
// and read them from the resource file
iUidArray = new (ELeave) CArrayFixFlat<TUid>(length);
for(index=0; index<length; index++)
{
const TInt typeindex = theReader.ReadInt8L();
const TUid uid = TUid::Uid(theReader.ReadInt32L());
//
iUidArray->InsertL(typeindex, uid);
}
CleanupStack::PopAndDestroy(&theReader);
// Read extarray in a similar way
theReader.OpenLC( &aResFile, EXTARRAY );
//the first WORD contains the number of elements in the resource
length = theReader.ReadInt16L();
// Create the array with appropriate granularity
iExtResultArray = new (ELeave) CArrayFixFlat<TInt64>(length);
// Initialize the array to contain zeros
for(index=0; index<length; index++)
{
iExtResultArray->InsertL(index, 0);
}
// Next, create the array for the actual extensions
// and read them from the resource file
iExtArray = new (ELeave) CDesCArrayFlat(length);
for(index=0; index<length; index++)
{
TInt typeindex = theReader.ReadInt8L();
TPtrC ext = theReader.ReadTPtrCL();
iExtArray->InsertL(typeindex, ext);
}
CleanupStack::PopAndDestroy( &theReader );
// Create the array for results per group
iGroupResultArray = new (ELeave) CArrayFixFlat<TInt64>(aNumberOfDataGroups);
// Initialize the array to contain zeros
for(index=0; index<aNumberOfDataGroups; index++)
{
iGroupResultArray->InsertL(index, 0);
}
// The directories to be scanned. Depends of which drive is scanned,
// and the directories that are scanned as a whole (and excluded in the normal scan)
_LIT(KPanic,"MSENG");
__ASSERT_ALWAYS((CMseng::IsInternalDrive(aFsSession, iCurrentScannedDrive)
|| CMseng::IsRemovableDrive(aFsSession, iCurrentScannedDrive)),
User::Panic(KPanic, KErrNotSupported));
if( CMseng::IsInternalDrive(aFsSession, iCurrentScannedDrive)
&& !CMseng::IsMassStorageDrive( aFsSession, iCurrentScannedDrive ) )
{
theReader.OpenLC( &aResFile, C_DIRECTORIES );
iDirArray = theReader.ReadDesCArrayL();
CleanupStack::PopAndDestroy( &theReader );
//
theReader.OpenLC( &aResFile, C_EXCLUDED_DIRECTORIES );
iExcludedDirArray = theReader.ReadDesCArrayL();
CleanupStack::PopAndDestroy( &theReader );
//
theReader.OpenLC( &aResFile, C_SPECIAL_DATADIRS );
// reading later...
}
else // other drives except Phone Memory should be scanned from root folder.
{
theReader.OpenLC( &aResFile, E_DIRECTORIES );
iDirArray = theReader.ReadDesCArrayL();
CleanupStack::PopAndDestroy( &theReader );
//
theReader.OpenLC( &aResFile, E_EXCLUDED_DIRECTORIES );
iExcludedDirArray = theReader.ReadDesCArrayL();
CleanupStack::PopAndDestroy( &theReader );
//
theReader.OpenLC( &aResFile, E_SPECIAL_DATADIRS );
// reading later...
}
// Apply correct drive letter in directory array names
TInt dirCount = iDirArray->Count();
for (TInt i=0; i<dirCount; i++)
{
HBufC* dirName = iDirArray->MdcaPoint(i).AllocLC();
TPtr ptrName = dirName->Des();
TBuf<1> drive;
TChar ch;
if ( RFs::DriveToChar( iCurrentScannedDrive, ch ) == KErrNone )
{
drive.Append(ch);
ptrName.Replace(0, drive.Length(), drive);
}
iDirArray->Delete(i);
iDirArray->InsertL(i, ptrName);
CleanupStack::PopAndDestroy(dirName);
}
// Apply correct drive letter in excluded directory array names
TInt exDirCount = iExcludedDirArray->Count();
for (TInt i=0; i<exDirCount; i++)
{
HBufC* dirName = iExcludedDirArray->MdcaPoint(i).AllocLC();
TPtr ptrName = dirName->Des();
TBuf<1> drive;
TChar ch;
if ( RFs::DriveToChar( iCurrentScannedDrive, ch ) == KErrNone )
{
drive.Append(ch);
ptrName.Replace(0, drive.Length(), drive);
}
iExcludedDirArray->Delete(i);
iExcludedDirArray->InsertL(i, ptrName);
CleanupStack::PopAndDestroy(dirName);
}
//the first WORD contains the number of elements in the resource
length = theReader.ReadInt16L();
// Create the arrays for special data dirs
iDataDirArray = new (ELeave) CDesCArrayFlat(length);
iDataDirGroupArray = new (ELeave) CArrayFixFlat<TInt>(length);
iDataDirExclArray = new (ELeave) CArrayPtrFlat<CDesCArray>(length);
// Read the array resource
for(TInt i=0; i<length; i++)
{
TInt groupindex = theReader.ReadInt8L();
TChar ch;
HBufC* name = theReader.ReadHBufCL();
CleanupStack::PushL(name);
TPtr ptrName = name->Des();
TBuf<1> drive;
TBool driveValid = EFalse;
if ( RFs::DriveToChar( iCurrentScannedDrive, ch ) == KErrNone )
{
driveValid = ETrue;
drive.Append(ch);
ptrName.Replace(0, drive.Length(), drive);
}
// Next WORD contains the number of excluded files
TInt lengthExcl = theReader.ReadInt16L();
TBool folderExists = EFalse;
// Add directory to the list to be scanned
if(driveValid && BaflUtils::FolderExists(aFsSession, ptrName))
{
folderExists = ETrue;
iDataDirArray->AppendL(ptrName);
iDataDirGroupArray->AppendL(groupindex);
iDataDirExclArray->AppendL(NULL);
CDesCArray* subarray = new (ELeave) CDesCArrayFlat( Max(lengthExcl, 1) );
const TInt dirCount = iDataDirExclArray->Count();
iDataDirExclArray->At(dirCount-1) = subarray;
}
for(TInt j=0; j<lengthExcl; j++)
{
TPtrC nameExcl = theReader.ReadTPtrCL();
// Append special file only if folder exists
if(folderExists)
{
const TInt dirCount = iDataDirExclArray->Count();
iDataDirExclArray->At(dirCount-1)->AppendL( nameExcl );
}
}
// If there was an error, we can assume it was because
// the folder does not exist, and ignore the error.
CleanupStack::PopAndDestroy( name );
}
CleanupStack::PopAndDestroy( &theReader );
#ifdef __SHOW_RDEBUG_PRINT_
RDebug::Print(_L("CMsengInfoArray constructed. Printing current configuration.\n Extensions:"));
for(TInt j=0; j < Exts().Count(); j++)
{
HBufC* ext = Exts().MdcaPoint(j).AllocL();
RDebug::Print(_L(" %d: %S"), j, ext);
delete ext;
}
RDebug::Print(_L(" UIDs:"));
for(TInt k=0; k < Uids().Count(); k++)
{
TUidName uid;
uid = Uids().At(k).Name();
RDebug::Print(_L(" %d: %S"), k, &uid);
}
#endif // __SHOW_RDEBUG_PRINT_
}
// ---------------------------------------------------------------------------
// CMsengInfoArray::~CMsengInfoArray()
//
// Destructor
// ---------------------------------------------------------------------------
CMsengInfoArray::~CMsengInfoArray()
{
// delete data structures
delete iUidResultArray;
delete iExtResultArray;
delete iGroupResultArray;
delete iUidArray;
delete iExtArray;
delete iDirArray;
delete iExcludedDirArray;
delete iDataDirArray;
delete iDataDirGroupArray;
if(iDataDirExclArray)
{
iDataDirExclArray->ResetAndDestroy();
}
delete iDataDirExclArray;
}
// ---------------------------------------------------------------------------
// CMsengInfoArray::IsExcludedDir()
//
//
// ---------------------------------------------------------------------------
TBool CMsengInfoArray::IsExcludedDir(const TDesC& aDirectory) const
{
TInt count = iExcludedDirArray->Count();
for(TInt i=0; i<count; i++)
{
if(aDirectory.FindF(iExcludedDirArray->MdcaPoint(i)) == 0)
{
return ETrue;
}
}
return EFalse;
}
// ---------------------------------------------------------------------------
// CMsengInfoArray::FolderExists()
//
//
// ---------------------------------------------------------------------------
TBool CMsengInfoArray::FolderExists(RFs& aFs, const TDesC& aPath)
{
TBool result = EFalse;
if(BaflUtils::FolderExists(aFs, aPath))
{
result = ETrue;
}
// BaflUtils::FolderExists return KErrBadName, if called with
// only drive letter (like "c:\")
else
{
TChar driveLetter;
if( RFs::DriveToChar(CurrentDrive(), driveLetter) == KErrNone)
{
TBuf<1> driveName;
driveName.Append(driveLetter);
TInt cmp = aPath.CompareF(BaflUtils::RootFolderPath(driveName));
result = (cmp == 0);
}
}
return result;
}
// ---------------------------------------------------------------------------
// CMsengInfoArray::IsSpecialDir()
//
//
// ---------------------------------------------------------------------------
TBool CMsengInfoArray::IsSpecialDir(const TDesC& aDirectory) const
{
TInt count = iDataDirArray->Count();
for(TInt i=0; i<count; i++)
{
if(aDirectory.FindF(iDataDirArray->MdcaPoint(i)) == 0)
{
return ETrue;
}
}
return EFalse;
}
// End of File