/*
* Copyright (c) 2002-2004 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: server implementation
*
*/
// INCLUDE FILES
#include <e32std.h>
#include <e32base.h>
#include <f32file.h>
#include <drmcommon.h>
#ifdef RD_MULTIPLE_DRIVE
#include <DriveInfo.h>
#endif
#include "DcfRepSrv.h"
#include "SearchLeaf.h"
#include "FileScan.h"
// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES
// CONSTANTS
// MACROS
// LOCAL CONSTANTS AND MACROS
_LIT( KWma, ".wma" );
_LIT( KWmv, ".wmv" );
_LIT( KAsf, ".asf" );
#ifdef RD_MULTIPLE_DRIVE
_LIT( KIgnoreDir1, "%c:\\sys" );
_LIT( KIgnoreDir2, "%c:\\private\\101F51F2" );
#else
_LIT( KIgnoreDir1, "c:\\sys" );
_LIT( KIgnoreDir2, "c:\\private\\101F51F2" );
#endif
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
#ifndef RD_MULTIPLE_DRIVE
LOCAL_C TBool IgnoreDir( TFileName& aDir );
#else // RD_MULTIPLE_DRIVE
LOCAL_C TBool IgnoreDir( RFs& aFs, TFileName& aDir );
#endif
// FORWARD DECLARATIONS
// ============================ LOCAL FUNCTIONS =================================
// ------------------------------------------------------------------------------
// Returns whether directory should be ignored or not
// ------------------------------------------------------------------------------
#ifndef RD_MULTIPLE_DRIVE
LOCAL_C TBool IgnoreDir( TFileName& aDir )
{
if ( !aDir.CompareF( KIgnoreDir1 ) ||
!aDir.CompareF( KIgnoreDir2 ) )
{
return ETrue;
}
return EFalse;
}
#else // RD_MULTIPLE_DRIVE
LOCAL_C TBool IgnoreDir( RFs& aFs, TFileName& aDir )
{
TInt driveNumber( -1 );
TChar driveLetter;
DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
aFs.DriveToChar( driveNumber, driveLetter );
TFileName ignore1;
TFileName ignore2;
ignore1.Format( KIgnoreDir1, (TUint)driveLetter );
ignore2.Format( KIgnoreDir2, (TUint)driveLetter );
if ( !aDir.CompareF( ignore1 ) ||
!aDir.CompareF( ignore2 ) )
{
return ETrue;
}
return EFalse;
}
#endif
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CFileScan::CFileScan
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CFileScan::CFileScan( RFs& aFs ) :
CActive( CActive::EPriorityStandard ),iServer(NULL),iFs(&aFs),iCurrentLeaf(NULL)
{
CleanInternal();
}
// -----------------------------------------------------------------------------
// CFileScan::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CFileScan::ConstructL()
{
TInt err = 0;
if ( !iFs )
{
err = KErrArgument;
}
else
{
err = KErrNone;
}
User::LeaveIfError( err );
}
// -----------------------------------------------------------------------------
// CFileScan::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CFileScan* CFileScan::NewL( RFs& aFs )
{
CFileScan* self = new( ELeave ) CFileScan( aFs );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// Destructor
CFileScan::~CFileScan()
{
CleanInternal();
iServer = NULL;
iFs = NULL;
}
// -----------------------------------------------------------------------------
// CFileScan::DoCancel
// Function is called when the request is completed
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CFileScan::DoCancel()
{
CleanInternal();
}
// -----------------------------------------------------------------------------
// CFileScan::IsProtected
// Function returns whether the specific file is protected or not
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CFileScan::IsProtected( const TDesC& aFileName , TBool& aIsDCF )
{
TInt err = KErrNone;
aIsDCF = EFalse;
err = iServer->ProcessFile( aFileName , aIsDCF );
if ( err && err != KErrNoMemory )
{
err = KErrNone;
}
return err;
}
// -----------------------------------------------------------------------------
// CFileScan::RunL
// Function is called when the request is completed
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CFileScan::RunL()
{
TInt err = KErrNone;
if ( iSearching && iServer->State()!=EStateIdle )
{
err = SearchNext();
if ( err == KErrCancel )
{
err = KErrNone;
}
if ( !err )
{
SetActive();
TRequestStatus* status = &iStatus;
User::RequestComplete( status , err );
}
}
else
{
CleanInternal();
iServer->CompleteScanning(err);
Deque();
}
if ( err )
{
CleanInternal();
iServer->CompleteScanning(err);
Deque();
}
}
// -----------------------------------------------------------------------------
// CFileScan::SearchContent
// Function starts the active objects to search protected file through whole file system
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CFileScan::SearchContent( CDcfRepSrv* aServer )
{
TInt err = KErrNone;
iServer = aServer;
CActiveScheduler::Add( this );
iSearching = ETrue;
err = SearchNext();
if ( err )
{
return err;
}
SetActive();
TRequestStatus* status = &iStatus;
User::RequestComplete( status , KErrNone );
return err;
}
// -----------------------------------------------------------------------------
// CFileScan::SearchDrive
// This function searches for the DCF files on target device
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CFileScan::SearchDrive()
{
_LIT( KDrive, "%c:");
TDriveList drivelist;
TChar driveLetter;
TInt driveNumber = EDriveA - 1;
TInt err = KErrNone;
#ifdef RD_MULTIPLE_DRIVE
TInt ramDrive( -1 );
TInt romDrive( -1 );
DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRam, ramDrive );
DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, romDrive );
#endif
err = iFs->DriveList( drivelist );
if ( iLastPosition != KNullDesC )
{
driveLetter = iLastPosition[0];
err = iFs->CharToDrive( driveLetter, driveNumber );
}
driveNumber++;
for ( ; driveNumber < KMaxDrives ; driveNumber++ )
{
#ifndef RD_MULTIPLE_DRIVE
if ( driveNumber == EDriveD || driveNumber == EDriveZ )
{
}
#else // RD_MULTIPLE_DRIVE
if ( driveNumber == ramDrive || driveNumber == romDrive )
{
}
#endif
else if ( drivelist[driveNumber] )
{
err = iFs->DriveToChar( driveNumber, driveLetter );
iLastPosition.Format( KDrive, (TUint)driveLetter );
iDeeper = ETrue;
return err;
}
}
CleanInternal();
return err;
}
// -----------------------------------------------------------------------------
// CFileScan::SearchFolder
// This function create Leaves for the current leaf
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CFileScan::SearchFolder( CDir*& aFolderList )
{
TInt err = KErrNone;
TRAP( err , iCurrentLeaf->SetLeafL( aFolderList ) );
return err;
}
// -----------------------------------------------------------------------------
// CFileScan::SearchFile
// This function searches for the DCF files under specific folder
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CFileScan::SearchFile( CDir*& aFileList )
{
TInt err = KErrNone;
TInt i = 0;
TBool isDCF;
_LIT ( KFullFileName , "%S\\%S");
TFileName fileName;
for ( ; i < aFileList->Count() && !err ; i++ )
{
if (!( *aFileList )[i].IsDir())
{
TPtrC extension = (*aFileList)[i].iName.Right( 4 );
if( !extension.CompareF( KWma ) ||
!extension.CompareF( KWmv ) ||
!extension.CompareF( KAsf ) )
{
}
else
{
fileName.Format( KFullFileName , &iLastPosition , &( *aFileList )[i].iName );
err = IsProtected( fileName , isDCF );
}
}
}
return err;
}
// -----------------------------------------------------------------------------
// CFileScan::SearchNext
// This function searches for the DCF files under specific folder or drive
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CFileScan::SearchNext()
{
TInt err = KErrNone;
err = CheckDrive();
if ( !err && iSearching )
{
if ( iDeeper )
{
err = CheckFolder();
}
if ( !err && iSearching )
{
err = ToNextLeaf();
}
}
return err;
}
TInt CFileScan::CheckDrive()
{
// check if current drive is end of searching
TInt err = KErrNone;
if( !iCurrentLeaf )
{
err = SearchDrive();
if ( err || !iSearching )
{
return err;
}
CSearchLeaf* root = NULL;
TRAP( err , iCurrentLeaf = CSearchLeaf::NewL( root , iLastPosition ) );
}
return err;
}
TInt CFileScan::CheckFolder()
{
// check current folder
_LIT ( KSearchDir , "%S\\*");
TInt err = KErrNone;
CDir* fileList = NULL;
CDir* dirList = NULL;
TFileName temp;
#ifndef RD_MULTIPLE_DRIVE
if ( IgnoreDir( iLastPosition ) )
#else // RD_MULTIPLE_DRIVE
if ( IgnoreDir( *iFs, iLastPosition ) )
#endif
{
return err;
}
if( iLastPosition.Length() + KSearchDir().Length() < iLastPosition.MaxLength() )
{
temp.Format( KSearchDir , &iLastPosition );
err = iFs->GetDir( temp
, KEntryAttMaskSupported
, ESortByName
, fileList , dirList );
if ( !err )
{
err = SearchFolder( dirList );
if ( !err )
{
err = SearchFile( fileList );
}
}
delete fileList;
fileList = NULL;
delete dirList;
dirList = NULL;
}
return err;
}
TInt CFileScan::ToNextLeaf()
{
_LIT ( KChildDir , "%S\\%S");
TInt err = KErrNone;
TFileName file;
CSearchLeaf* temp = NULL;
file.Format( iLastPosition );
if ( iCurrentLeaf->LeafList().Count() > 0 )
{
iDeeper = ETrue;
iCurrentLeaf = iCurrentLeaf->LeafList()[0];
iLastPosition.Format( KChildDir , &file , &iCurrentLeaf->FolderName() );
}
else
{
iDeeper = EFalse;
temp = iCurrentLeaf;
iCurrentLeaf = iCurrentLeaf->Root();
if ( iCurrentLeaf )
{
iCurrentLeaf->RemoveLeaf( temp );
}
delete temp;
temp = NULL;
err = UpFolder();
}
return err;
}
TInt CFileScan::UpFolder()
{
TInt err = KErrNone;
TParse file;
if ( iLastPosition.Length()<3 )
{
return err;
}
err = file.Set( iLastPosition , NULL , NULL );
iLastPosition.Format( file.DriveAndPath() );
iLastPosition.SetLength( iLastPosition.Length() - 1 );
return err;
}
void CFileScan::CleanInternal()
{
CSearchLeaf* root = iCurrentLeaf;
iLastPosition = KNullDesC;
iSearching = EFalse;
root = GetRootLeaf();
delete root;
root = NULL;
iCurrentLeaf = NULL;
iDeeper = ETrue;
}
CSearchLeaf* CFileScan::GetRootLeaf()
{
CSearchLeaf* root = iCurrentLeaf;
if ( iCurrentLeaf )
{
while ( root->Root() )
{
root = root->Root();
}
}
return root;
}
// End of File