/*
* Copyright (c) 2003-2006 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:  Operation independent remote file handling functions
*
*/

#ifndef C_RSFWFILEENGINE_H
#define C_RSFWFILEENGINE_H

#include "rsfwinterface.h"
#include "rsfwremoteaccess.h"

class CRsfwLockManager;
class TDirEnt;
class CRsfwFileTable;
class CRsfwRfeStateMachine;
class CRsfwVolume;
class CRsfwFileEntry;

// Default values for various operation parameters
const TInt KDefaultMaxCacheSize             = (16 * 1024 * 1024); // 16 MB
const TInt KDefaultMaxEntryCount            = 1024;
const TInt KDefaultCacheValidity            = 30;            // in seconds
const TInt KDefaultDirCacheValidity         = 30;
const TInt KDefaultRecognizerLimit          = 256;
const TInt KDefaultJpegLimit                = 0;            
const TInt KDefaultMpegLimit                = 10000;


class CRsfwFileEngine: public CBase, public MRsfwRemoteAccessObserver
    {
public:
    static CRsfwFileEngine* NewL(CRsfwVolume* aVolume);
    static CRsfwFileEngine* NewLC(CRsfwVolume* aVolume);
    ~CRsfwFileEngine();
    
    void DispatchL(TRfeInArgs& aIn, TRfeOutArgs& aOut);
    HBufC* FullNameLC(CRsfwFileEntry& aFe);
    HBufC* FullNameL(CRsfwFileEntry& aFe);
    void SetupAttributes(CRsfwFileEntry& aFe);
    void MakeDirectoryEntry(CRsfwFileEntry& aFe, TDirEnt& aDirEnt);
    void UpdateDirectoryContainerL(CRsfwFileEntry& aFe);
    TBool DataChanged(const CRsfwDirEntAttr& oldAttr, const CRsfwDirEntAttr& newAttr);
    TBool UseCachedData(CRsfwFileEntry& aFe);    
    TBool UseCachedAttributes(CRsfwFileEntry& aFe);
    void GetAttributesL(CRsfwFileEntry& aFe,
                        CRsfwDirEntAttr*& aAttr,
                        TUint aNodeType, 
                        CRsfwRfeStateMachine* aCaller = NULL);
    void UpdateAttributesL(TDesC& aPath,
                           TDesC& aName,
                           CRsfwDirEntAttr*& aAttr,
                           TUint aNodeType,
                           MRsfwRemoteAccessResponseHandler* aCaller = NULL);
    void UpdateAttributesL(CRsfwFileEntry& aFe, 
                           CRsfwDirEntAttr*& aAttr, 
                           TUint aNodeType, 
                           MRsfwRemoteAccessResponseHandler* aCaller = NULL);
    void UpdateAttributesL(TDesC& aFullPath, 
                           CRsfwDirEntAttr*& aAttr, 
                           TUint aNodeType, 
                           MRsfwRemoteAccessResponseHandler* aCaller = NULL);
    void CreateContainerFileL(CRsfwFileEntry& aFe);
    TUint FetchAndCacheL(CRsfwFileEntry& aFe,
                        TInt aFirstByte,
                        TInt* aLength, 
                        RPointerArray<CRsfwDirEnt>* aDirEntsp,
                        CRsfwRfeStateMachine* aCaller = NULL);                                                         
    TUint RequestConnectionStateL(TUint aConnectionState,
                                 CRsfwRfeStateMachine* aCaller = NULL);                                                                  
    void EnteredConnectionStateL(TUint aConnectionState, TBool aRequested);
    TUint ConnectionState();
    CRsfwLockManager* LockManager();       
    void SetPermanenceL(TBool aPermanence);
    TBool Disconnected();
    TBool WriteDisconnected();
    TInt AddToCacheL(CRsfwFileEntry& aFe, 
                     RPointerArray<CRsfwDirEnt>* aDirEnts, 
                     CRsfwFileEngine *aFileEngine, 
                     TUint cachedSize);
    CRsfwRemoteAccess* RemoteAccessL();
    void OperationCompleted();
    void CancelTransactionL(TDesC& aPathName);
    void CancelTransaction(TUint aTransactionId);
    void SetFailedLookup(TDesC& aPath, TDesC& aKidName); 
    void ResetFailedLookup();
    CRsfwVolume* Volume();
    TInt PurgeFromCache(const TDesC& aPath);
    HBufC8* GetContentType(TDesC& aName); 
    CRsfwFileEntry* FetchFep(const TDesC& aPath);

private:
    void ConstructL(CRsfwVolume* aVolume);
    void PrepareCacheL();
    TInt UpdateDirectoryL(CRsfwFileEntry& aFe, TDesC* aFullName);
    TInt UpdateDirectoryL(CRsfwFileEntry& aFe);
    TUint GetDirectoryL(CRsfwFileEntry& aFe,
                       TDesC& aFullName,
                       RFile& aF,
                       RPointerArray<CRsfwDirEnt>* aDirEntsp, 
                       MRsfwRemoteAccessResponseHandler* aCaller = NULL);
    void BuildContainerPathL(CRsfwFileEntry& aFe, TDes& aPath);
    void ApplyMultiDirCacheL(TDes& aPath); 
    void CreateContainerFileL(CRsfwFileEntry& aFe, TDes& aPath, RFile& aF);
    void DoCreateL(TRfeCreateInArgs& aIn, TRfeCreateOutArgs& aOut);
    void DoIoctlL(TRfeIoctlInArgs& aIn,TRfeOutArgs& aOut);
    void DoRootL(TRfeRootInArgs& aIn, TRfeRootOutArgs& aOut);
    void DoSetAttrL(TRfeSetAttrInArgs& aIn, TRfeOutArgs& aOut);
    void SetupRootL(TBool aPermanence);
    void CleanupCorruptedCacheL();
    TUint ConnectL(TBool aRestart, CRsfwRfeStateMachine* aCaller = NULL);
    void DisconnectL();
    void StartInactivityTimer();
    void StopInactivityTimer();
    static TInt InactivityTimerExpired(TAny* aArg);
   
    
    // the purpose of these functions is to give capability info
    // for the access protocol plugin used
    
    // whether getting the directory listing also gives reliable file metadata
    TBool DirectoryListingContainsFileMetadata();
    
    // from MRsfwRemoteAccessObserver
    void HandleRemoteAccessEventL(TInt aEventType, TInt aEvent, TAny* aArg);

public:
    CRsfwFileTable*    iFileTable;         // table of known vnodes, by fid
    TUint          iConnectionState;   // connection state
    CRsfwRemoteAccess* iRemoteAccess;      // remote file transport module
    CRsfwLockManager*  iLockManager;       // implement locking for files
 
private:
    
	// Data
    CRsfwFileEntry*    iRootFep;           // root file entry
    CRsfwVolume*       iVolume;            // volume info
    const TFid*    iRootFid;           // root file id
    TFileName      iCacheRoot;         // location of local cache files
    RFs            iFs;                // fileserver handle
    TInt           iInactivityTimeout; // inactivity timeout
    CPeriodic*     iInactivityTimer;   // remote access inactivity watch dog
    TBool          iConnectionStateChanged;
    TFileName      iLastFailedLookup;   // path of the last failed lookup, cached 
    TTime          iLookupTime; 		// then this failed lookup happened      
    };


#endif