--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/src/sconfolderlister.cpp Wed Sep 01 12:20:56 2010 +0100
@@ -0,0 +1,717 @@
+/*
+* Copyright (c) 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: CSconFolderLister implementation
+*
+*/
+
+
+#include "sconfolderlister.h"
+
+#include <driveinfo.h>
+#include <centralrepository.h>
+#include <sysutildomaincrkeys.h>
+#include <CDirectoryLocalizer.h>
+#include <stringresourcereader.h>
+#include <sconftp.rsg>
+#include <bautils.h>
+
+#include "debug.h"
+
+const TUint16 KFormatVersion( 1 );
+
+// Obex package size
+const TInt KPackageSize = 65536;
+
+const TInt KMaxLevelsToSearch = 80;
+
+_LIT( KSConResourceName, "z:\\Resource\\sconftp.rsc" );
+
+CSconFolderEntry* CSconFolderEntry::NewLC()
+ {
+ CSconFolderEntry* self = new (ELeave) CSconFolderEntry();
+ CleanupStack::PushL( self );
+ return self;
+ }
+CSconFolderEntry* CSconFolderEntry::NewLC( const TEntry& aEntry )
+ {
+ CSconFolderEntry* self = new (ELeave) CSconFolderEntry();
+ CleanupStack::PushL( self );
+ self->ConstructL( aEntry );
+ return self;
+ }
+CSconFolderEntry::CSconFolderEntry()
+ {
+ }
+CSconFolderEntry::~CSconFolderEntry()
+ {
+ delete iName;
+ delete iLabel;
+ }
+
+
+void CSconFolderEntry::ConstructL( const TEntry& aEntry )
+ {
+ iAtt = aEntry.iAtt;
+ iModified = aEntry.iModified.Int64();
+ iName = aEntry.iName.AllocL();
+ }
+
+CSconFolderLister::CSconFolderLister( RFs& aFs ) : iFs(aFs)
+ {
+ // No implementation required
+ }
+
+CSconFolderLister::~CSconFolderLister()
+ {
+ TRACE_FUNC;
+ delete iLocalizer;
+ }
+
+CSconFolderLister* CSconFolderLister::NewL( RFs& aFs )
+ {
+ TRACE_FUNC_ENTRY;
+ CSconFolderLister* self = new (ELeave) CSconFolderLister( aFs );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ TRACE_FUNC_EXIT;
+ return self;
+ }
+
+void CSconFolderLister::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ iLocalizer = CDirectoryLocalizer::NewL();
+
+ // set free memory up to critical level for all drives
+ CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );
+ TInt iCriticalLevel(0);
+ User::LeaveIfError( repository->Get( KDiskCriticalThreshold, iCriticalLevel ) );
+ CleanupStack::PopAndDestroy( repository );
+ iCriticalLevel += KPackageSize; // add obex package size to critical level
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconFolderLister::GenerateFolderListL( RBufWriteStream& aStream, const TDesC& aStartPath,
+ const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aStartPath: %S", &aStartPath );
+ LOGGER_WRITE_1("aLevelsToSearch: %d", aLevelsToSearch );
+ TInt levelsToSearch = aLevelsToSearch;
+ if ( levelsToSearch > KMaxLevelsToSearch || levelsToSearch == KErrNotFound )
+ levelsToSearch = KMaxLevelsToSearch;
+ iFolders = 0;
+ iFiles = 0;
+ const TInt KDriveNameLength( 3 );
+
+ if ( aStartPath.CompareF( _L("\\") ) == 0 )
+ {
+ LOGGER_WRITE("List all drives");
+ aStream.WriteUint16L( KFormatVersion );
+ ListAllDrivesL( aStream, levelsToSearch );
+ }
+ else if ( aStartPath.Length() >= KDriveNameLength )
+ {
+ if ( aStartPath.Length() > KDriveNameLength )
+ {
+ // check root path permissions, is listing allowed
+ TPtrC path = aStartPath.Mid(KDriveNameLength);
+ LOGGER_WRITE_1("pathFromRoot: %S", &path);
+ TInt pathEndMark = path.Locate(TChar('\\'));
+ if ( pathEndMark == KErrNotFound )
+ {
+ User::Leave( KErrArgument );
+ }
+ //"private\" locate = 7"
+ TPtrC pathName = aStartPath.Left( KDriveNameLength+pathEndMark );
+ LOGGER_WRITE_1("pathName: %S", &path);
+ TEntry pathEntry;
+ User::LeaveIfError( iFs.Entry(pathName, pathEntry) );
+
+ TBool printable = IsDirectoryPrintable( aStartPath.Left(3), pathEntry );
+ if ( !printable )
+ {
+ // access denied
+ LOGGER_WRITE("Access denied!");
+ User::Leave( KErrAccessDenied );
+ }
+ User::LeaveIfError( iFs.Entry(aStartPath, pathEntry) );
+ if ( pathEntry.IsSystem() )
+ {
+ // access denied
+ LOGGER_WRITE("System folder, Access denied!");
+ User::Leave( KErrAccessDenied );
+ }
+ }
+
+
+ aStream.WriteUint16L( KFormatVersion );
+
+ TInt drive;
+ User::LeaveIfError( iFs.CharToDrive( aStartPath[0], drive) );
+ ListDriveAndPathL( aStream, drive, aStartPath, levelsToSearch);
+
+ }
+ else
+ {
+ LOGGER_WRITE("aStartPath KErrArgument");
+ User::Leave( KErrArgument );
+ }
+
+
+ LOGGER_WRITE_1("iFolders: %d", iFolders);
+ LOGGER_WRITE_1("iFiles: %d", iFiles);
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::ListAllDrivesL( RBufWriteStream& aStream, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt devDriveCount = 0;
+ TInt mmcDriveCount = 0;
+ TChar driveLetter;
+ TBuf8<1> driveBuf;
+ RArray<TSconDriveInfo> sconDriveInfo(5);
+
+ // Write all drives to folderlisting object
+ TDriveList driveList;
+ // Get all drives that are visible to the user.
+ TInt driveCount;
+ User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveList, driveCount ) );
+
+ for( TInt i = EDriveA; i < KMaxDrives; i++ )
+ {
+ if( driveList[i] )
+ {
+ TUint driveStatus;
+ User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, i, driveStatus ) );
+ //LOGGER_WRITE_1( "DriveInfo for drive: %d", i);
+
+ if( !(driveStatus & DriveInfo::EDrivePresent )
+ || driveStatus & DriveInfo::EDriveCorrupt
+ || (driveStatus & DriveInfo::EDriveRemote) )
+ {
+ //LOGGER_WRITE_1( "skip drive %d", i);
+ continue;
+ }
+
+ User::LeaveIfError( iFs.DriveToChar( i, driveLetter ) );
+ //Letter to uppercase form.
+ driveLetter.UpperCase();
+
+ TSconDriveInfo info;
+ info.iDriveStatus = driveStatus;
+ info.iDriveLetter.Zero();
+ info.iDriveLetter.Append( driveLetter );
+ info.iDriveLetter.Append( _L(":") );
+
+
+ info.iDriveAttr = KEntryAttNormal; // ReadWrite
+
+ if( driveStatus & DriveInfo::EDriveInternal && devDriveCount==0 )
+ {
+ //permission always R for first internal drive
+ info.iDriveAttr = KEntryAttReadOnly;
+ }
+
+ //memory type
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ LOGGER_WRITE( "DriveInfo::EDriveInternal" );
+ devDriveCount++;
+ info.iDriveType = DriveInfo::EDriveInternal; // =1
+ info.iDriveTypeCount = devDriveCount;
+
+ }
+ else if( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ LOGGER_WRITE( "DriveInfo::EDriveRemovable" );
+ mmcDriveCount++;
+ info.iDriveType = DriveInfo::EDriveRemovable;; // =2
+ info.iDriveTypeCount = mmcDriveCount;
+ }
+
+ TVolumeInfo volumeInfo;
+ User::LeaveIfError( iFs.Volume( volumeInfo, i) );
+
+ info.iVolumeName = volumeInfo.iName;
+ if ( volumeInfo.iFree > iCriticalLevel )
+ {
+ volumeInfo.iFree = volumeInfo.iFree - iCriticalLevel;
+ }
+ else
+ {
+ volumeInfo.iFree = 0;
+ }
+
+ info.iFree = volumeInfo.iFree;
+ info.iSize = volumeInfo.iSize;
+
+
+ sconDriveInfo.AppendL( info );
+
+ }
+ }
+
+ LOGGER_WRITE_1("Drives: %d", sconDriveInfo.Count());
+ aStream.WriteUint8L( sconDriveInfo.Count() );
+ for ( TInt i=0; i < sconDriveInfo.Count(); i++ )
+ {
+
+ TBuf<3> path(KNullDesC);
+ path.Copy(sconDriveInfo[i].iDriveLetter);
+ path.Append(_L("\\"));
+
+ ExportDriveL( aStream, sconDriveInfo[i], path, aLevelsToSearch);
+ }
+ sconDriveInfo.Close();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::ListDriveAndPathL( RBufWriteStream& aStream, TInt aDrive, const TDesC& aStartPath, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ TVolumeInfo volumeInfo;
+ User::LeaveIfError( iFs.Volume(volumeInfo, aDrive) );
+ TInt driveCount(0);
+ TUint driveStatus;
+ User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, aDrive, driveStatus ) );
+ GetDriveTypeNumberL( aDrive, driveStatus, driveCount );
+
+
+ TSconDriveInfo info;
+ info.iDriveLetter.Copy( aStartPath.Left(2) );
+ info.iVolumeName = volumeInfo.iName;
+
+ info.iDriveAttr = KEntryAttNormal; // ReadWrite
+ if( driveStatus & DriveInfo::EDriveInternal && driveCount==0 )
+ {
+ //permission always R for first internal drive
+ info.iDriveAttr = KEntryAttReadOnly;
+ }
+ info.iDriveType = 0;
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ info.iDriveType = DriveInfo::EDriveInternal; // =1
+ }
+ else if( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ info.iDriveType = DriveInfo::EDriveRemovable;; // =2
+ }
+
+ if ( volumeInfo.iFree > iCriticalLevel )
+ {
+ volumeInfo.iFree = volumeInfo.iFree - iCriticalLevel;
+ }
+ else
+ {
+ volumeInfo.iFree = 0;
+ }
+
+ info.iFree = volumeInfo.iFree;
+ info.iSize = volumeInfo.iSize;
+
+ aStream.WriteUint8L( 1 );
+ ExportDriveL( aStream, info, aStartPath, aLevelsToSearch);
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::ExportDriveL( RBufWriteStream& aStream, const TSconDriveInfo& aDriveInfo,
+ const TDesC& aPathName, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("Drive: %S", &aDriveInfo.iDriveLetter);
+ LOGGER_WRITE_1("aLevelsToSearch: %d", aLevelsToSearch );
+
+ CSconFolderEntry* driveEntry = CSconFolderEntry::NewLC();
+ driveEntry->iName = aDriveInfo.iDriveLetter.AllocL();
+
+ if ( driveEntry->iLabel )
+ {
+ LOGGER_WRITE_1("Label: %S", &driveEntry->iLabel->Des());
+ }
+ driveEntry->iAtt = aDriveInfo.iDriveAttr;
+
+ driveEntry->iDriveInfoEntryExists = ETrue;
+ driveEntry->iDriveInfoEntry.iDriveType = aDriveInfo.iDriveType;
+ driveEntry->iDriveInfoEntry.iDriveTypeCount = aDriveInfo.iDriveTypeCount;
+
+ driveEntry->iDriveInfoEntry.iFree = aDriveInfo.iFree;
+ driveEntry->iDriveInfoEntry.iSize = aDriveInfo.iSize;
+
+ driveEntry->iLabel = aDriveInfo.iVolumeName.AllocL();
+ GetLocalizedVolumeNameL( *driveEntry );
+
+ ExportPathL( aStream, aPathName, *driveEntry, ETrue, aLevelsToSearch );
+ CleanupStack::PopAndDestroy( driveEntry );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::GetLocalizedVolumeNameL( CSconFolderEntry& aDriveEntry )
+ {
+ TRACE_FUNC_ENTRY;
+ // Get localized names
+ if ( aDriveEntry.iDriveInfoEntry.iDriveType == DriveInfo::EDriveInternal
+ && aDriveEntry.iDriveInfoEntry.iDriveTypeCount > 1 )
+ {
+ LOGGER_WRITE("Internal mass memory");
+ // internal second memory (Mass memory)
+ TFileName file( KSConResourceName );
+ BaflUtils::NearestLanguageFile( iFs, file );
+
+ CStringResourceReader* reader = CStringResourceReader::NewL( file );
+ if ( aDriveEntry.iLabel )
+ {
+ delete aDriveEntry.iLabel;
+ aDriveEntry.iLabel = NULL;
+ }
+ aDriveEntry.iLabel = reader->ReadResourceString( R_SECON_VALUE_MASS_STORAGE ).AllocL();
+ delete reader;
+ }
+ else if ( aDriveEntry.iLabel && aDriveEntry.iLabel->Length()>0 )
+ {
+ LOGGER_WRITE("Use normal volume label");
+
+ }
+ else
+ {
+ TFileName file( KSConResourceName );
+ BaflUtils::NearestLanguageFile( iFs, file );
+ CStringResourceReader* reader = CStringResourceReader::NewL( file );
+ if (aDriveEntry.iLabel)
+ {
+ delete aDriveEntry.iLabel;
+ aDriveEntry.iLabel = NULL;
+ }
+ if ( aDriveEntry.iDriveInfoEntry.iDriveType == DriveInfo::EDriveRemovable )
+ {
+ LOGGER_WRITE("EDriveRemovable");
+ // read default MMC name
+ aDriveEntry.iLabel = reader->ReadResourceString( R_SECON_VALUE_MMC ).AllocL();
+ }
+ else
+ {
+ LOGGER_WRITE("EDriveInternal");
+ // read default DEV name
+ aDriveEntry.iLabel = reader->ReadResourceString( R_SECON_VALUE_DEVICE ).AllocL();
+ }
+ delete reader;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSconFolderLister::GetDriveTypeNumberL()
+//
+// -----------------------------------------------------------------------------
+//
+void CSconFolderLister::GetDriveTypeNumberL( TInt aDrive, TUint aDriveStatus , TInt& aTypeNumber)
+ {
+ TRACE_FUNC_ENTRY;
+ aTypeNumber = 0;
+
+ //TUint driveStatus;
+ //
+ // if true, search internal drives, else search removable drives
+ TBool searchInternalDrives = (aDriveStatus & DriveInfo::EDriveInternal);
+
+ TInt driveCount;
+ TDriveList driveList;
+
+ User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveList, driveCount ) );
+
+ for( TInt i = EDriveA; i <= aDrive; i++ )
+ {
+ if( driveList[i] )
+ {
+ TUint driveStatus;
+ User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, i, driveStatus ) );
+
+ if( !(driveStatus & DriveInfo::EDrivePresent )
+ || driveStatus & DriveInfo::EDriveCorrupt )
+ {
+ LOGGER_WRITE( "not present or corrupted" );
+ continue;
+ }
+
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ if( searchInternalDrives )
+ {
+ aTypeNumber++;
+ }
+ }
+ else if( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ if( !searchInternalDrives )
+ {
+ aTypeNumber++;
+ }
+ }
+ }
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconFolderLister::ExportPathL( RBufWriteStream& aStream, const TDesC& aPathName,
+ const CSconFolderEntry& aEntry, const TBool aLocalize, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aPathName: %S", &aPathName );
+ LOGGER_WRITE_1("aLevelsToSearch: %d", aLevelsToSearch );
+
+ LOGGER_WRITE_1("aEntry.iName: %S", &aEntry.iName->Des() );
+
+ TBool localized(EFalse);
+
+ // foldername length + name
+ aStream.WriteUint8L( aEntry.iName->Length() );
+ aStream.WriteL( aEntry.iName->Des() );
+
+ TUint att = aEntry.iAtt;
+
+ if ( aEntry.iLabel && aEntry.iLabel->Length() > 0 )
+ {
+ aStream.WriteUint8L( aEntry.iLabel->Length() );
+ aStream.WriteL( aEntry.iLabel->Des() );
+ }
+ else
+ {
+ if ( aLocalize )
+ {
+ // initialize Localizer
+ iLocalizer->SetFullPath( aPathName );
+ localized = iLocalizer->IsLocalized();
+ }
+
+ if( localized )
+ {
+ const TDesC& localizedName = iLocalizer->LocalizedName();
+ aStream.WriteUint8L( localizedName.Length() );
+ aStream.WriteL( localizedName );
+ LOGGER_WRITE_1("LocalizedName: %S", &localizedName );
+ }
+ else if ( aPathName.CompareF(_L("C:\\Data\\")) == 0 )
+ {
+ TFileName file( KSConResourceName );
+
+ BaflUtils::NearestLanguageFile( iFs, file );
+
+ CStringResourceReader* reader = CStringResourceReader::NewL( file );
+ CleanupStack::PushL( reader );
+
+ const TDesC& localizedName = reader->ReadResourceString( R_SECON_DATA_FOLDER );
+ aStream.WriteUint8L( localizedName.Length() );
+ aStream.WriteL( localizedName );
+ LOGGER_WRITE_1("LocalizedName: %S", &localizedName );
+
+ CleanupStack::PopAndDestroy( reader );
+ localized = ETrue;
+ }
+ else
+ {
+ aStream.WriteUint8L( 0 );
+ }
+ // attributes
+ if ( localized )
+ {
+ // localized folder, set readonly flag
+ att = att | KEntryAttReadOnly;
+ }
+ }
+
+ if ( aPathName.Length() == 3 && aLocalize )
+ {
+ // enable subfolder localization, even when root cannot be localized
+ localized = ETrue;
+ }
+
+ // DriveInfoEntry
+ if ( aEntry.iDriveInfoEntryExists )
+ {
+ aStream.WriteUint8L( 1 );
+ aStream.WriteUint8L( aEntry.iDriveInfoEntry.iDriveType );
+ aStream.WriteUint8L( aEntry.iDriveInfoEntry.iDriveTypeCount );
+ aStream << aEntry.iDriveInfoEntry.iFree;
+ aStream << aEntry.iDriveInfoEntry.iSize;
+ }
+ else
+ {
+ aStream.WriteUint8L( 0 );
+ }
+
+
+ // modified time
+ TDateTime time = aEntry.iModified.DateTime();
+ aStream.WriteInt16L( time.Year() );
+ aStream.WriteInt8L( time.Month()+1 ); // range 1...12
+ aStream.WriteInt8L( time.Day()+1 );
+ aStream.WriteInt8L( time.Hour() );
+ aStream.WriteInt8L( time.Minute() );
+ aStream.WriteInt8L( time.Second() );
+
+ // write attribute
+ aStream.WriteUint32L( att );
+
+
+ if ( aLevelsToSearch == 0 )
+ {
+ // don't list directory content
+ LOGGER_WRITE("Not listing directory content");
+ aStream.WriteInt16L( 0 ); // files count
+ aStream.WriteInt16L( 0 ); // directory count
+ return;
+ }
+
+ CDir *fileList = 0;
+ CDir *dirList = 0;
+
+ // show normal and hidden files and folders
+ TUint entryAttMask = KEntryAttNormal | KEntryAttHidden;
+
+ // get folders and files
+ TInt err = iFs.GetDir( aPathName, entryAttMask, ESortByName,
+ fileList, dirList );
+
+ if ( err )
+ {
+ LOGGER_WRITE_1( "ParseFolderListL GetDir returned: %d", err );
+ User::Leave( err );
+ }
+
+ CleanupStack::PushL( dirList );
+ CleanupStack::PushL( fileList );
+
+
+ LOGGER_WRITE_1("files: %d", fileList->Count());
+ aStream.WriteUint16L( fileList->Count() );
+
+ // Print files to folder listing object
+ for( TInt i = 0; i < fileList->Count(); i++ )
+ {
+ const TEntry& fileEntry = ( *fileList )[i];
+ iFiles++;
+ LOGGER_WRITE_1("fileEntry.iName: %S", &fileEntry.iName);
+ // filename length + name
+ aStream.WriteUint8L( fileEntry.iName.Length() );
+ aStream.WriteL( fileEntry.iName );
+
+ // modified time
+ TDateTime time = fileEntry.iModified.DateTime();
+ aStream.WriteInt16L( time.Year() );
+ aStream.WriteInt8L( time.Month()+1 ); // range 1...12
+ aStream.WriteInt8L( time.Day()+1 );
+ aStream.WriteInt8L( time.Hour() );
+ aStream.WriteInt8L( time.Minute() );
+ aStream.WriteInt8L( time.Second() );
+
+ // attributes
+ aStream.WriteUint32L( fileEntry.iAtt );
+
+ // file size
+ aStream.WriteUint32L( fileEntry.iSize );
+ }
+ CleanupStack::PopAndDestroy( fileList );
+
+
+ // calculate ow many directories we are going to list
+ TInt directoryCount(0);
+ for( TInt i = 0; i < dirList->Count(); i++ )
+ {
+ if ( IsDirectoryPrintable(aPathName, ( *dirList )[i] ) )
+ {
+ directoryCount++;
+ }
+ }
+ LOGGER_WRITE_1("directories: %d", directoryCount);
+ aStream.WriteUint16L( directoryCount );
+
+ HBufC* fullpath = HBufC::NewL( KMaxPath );
+ TPtr fullpathPtr = fullpath->Des();
+ CleanupStack::PushL( fullpath );
+
+ // Print folders to folder listing object
+ for( TInt i = 0; i < dirList->Count(); i++ )
+ {
+ const TEntry& folderEntry = ( *dirList )[i];
+ if ( !IsDirectoryPrintable(aPathName, folderEntry) )
+ {
+ continue;
+ }
+ iFolders++;
+
+ fullpathPtr.Copy( aPathName );
+ fullpathPtr.Append( folderEntry.iName );
+ fullpathPtr.Append( _L("\\") );
+ CSconFolderEntry* subFolderEntry = CSconFolderEntry::NewLC( folderEntry );
+ if ( aLevelsToSearch == KErrNotFound )
+ {
+ ExportPathL( aStream, fullpathPtr, *subFolderEntry, localized, aLevelsToSearch);
+ }
+ else
+ {
+ ExportPathL( aStream, fullpathPtr, *subFolderEntry, localized, aLevelsToSearch-1);
+ }
+ CleanupStack::PopAndDestroy( subFolderEntry );
+ }
+ CleanupStack::PopAndDestroy( fullpath );
+ CleanupStack::PopAndDestroy( dirList );
+
+ TRACE_FUNC_EXIT;
+ }
+TBool CSconFolderLister::IsDirectoryPrintable( const TDesC& aParentPath, const TEntry& aFolderEntry )
+ {
+ if ( aFolderEntry.IsSystem() )
+ {
+ LOGGER_WRITE_1("folder '%S' was system folder", &aFolderEntry.iName);
+ return EFalse;
+ }
+ if ( aParentPath.Length() == 3 )
+ {
+ if ( aParentPath.FindF(_L("C:\\")) == 0 && aFolderEntry.iName.CompareF(_L("data")) != 0 )
+ {
+ // C root not visible, exept Data folder
+ LOGGER_WRITE_1("folder '%S' not visible to user in c-root", &aFolderEntry.iName);
+ return EFalse;
+ }
+
+ if ( aFolderEntry.iName.CompareF(_L("private")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ else if ( aFolderEntry.iName.CompareF(_L("sys")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ else if ( aFolderEntry.iName.CompareF(_L("system")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ else if ( aFolderEntry.iName.CompareF(_L("resource")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+