// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// f32\inc\f32plugin.h
//
// WARNING: This file contains some APIs which are internal and are subject
// to change without notice. Such APIs should therefore not be used
// outside the Kernel and Hardware Services package.
//
/**
@file
@internalTechnology
*/
#if !defined(__F32PLUGIN_H__)
#define __F32PLUGIN_H__
#include <f32file.h>
#include <f32file_private.h>
#include <f32fsys.h>
const TInt KPluginMessageForward = 1; ///< Returned from ::Dispatch() to indicate that a request has been processed synchronously and should be passed down the stack.
const TInt KPluginMessageComplete = 2; ///< Returned from ::Dispatch() to indicate that a request has been processed synchronously and should be passed back up the stack.
const TInt KCountNeeded=KMinTInt;
/**
List of file server operations
*/
enum TFsMessage
{
EFsAddFileSystem, ///< Adds a file system
EFsRemoveFileSystem, ///< Removes a file system
EFsMountFileSystem, ///< Mounts a file system
EFsNotifyChange, ///< Notifies file and/or directory change
EFsNotifyChangeCancel, ///< Cancels change notification
EFsDriveList, ///< Gets a list of the available drive
EFsDrive, ///< Gets information about a drive and the medium mounted on it
EFsVolume, ///< Gets volume information for a formatted device
EFsSetVolume, ///< Sets the label for a volume
EFsSubst, ///< Gets the path assigned to a drive letter
EFsSetSubst, ///< -- 10, Assigns a path to a drive letter
EFsRealName, ///< Gets the real name of a file
EFsDefaultPath, ///< Gets the system default path
EFsSetDefaultPath, ///< Sets the system default path
EFsSessionPath, ///< Gets the session path
EFsSetSessionPath, ///< Sets the session path for the current file server client
EFsMkDir, ///< Makes directory
EFsRmDir, ///< Removes a directory
EFsParse, ///< Parses a filename specification
EFsDelete, ///< Deletes file
EFsRename, ///< -- 20 Renames a single file or directory
EFsReplace, ///< Replaces a single file with another
EFsEntry, ///< Gets a file's attributes
EFsSetEntry, ///< Sets both the attributes and the last modified date and time for a file or directory
EFsGetDriveName, ///< Gets the name of a drive
EFsSetDriveName, ///< Sets the name of a drive
EFsFormatSubClose, ///< Closes the Format subsession
EFsDirSubClose, ///< Closes the directory.
EFsFileSubClose, ///< Closes the file
EFsRawSubClose, ///< Closes the direct access channel to the disk
EFsFileOpen, ///< -- 30 Opens file
EFsFileCreate, ///< Creates and opens a new file
EFsFileReplace, ///< Replaces a file of the same name or creates a new file
EFsFileTemp, ///< Creates and opens a temporary file
EFsFileRead, ///< Reads from the file
EFsFileWrite, ///< Writes to the file
EFsFileLock, ///< Locks a region within the file
EFsFileUnLock, ///< Unlocks a region within the file
EFsFileSeek, ///< Sets the the current file position
EFsFileFlush, ///< Commits data to the storage device
EFsFileSize, ///< -- 40 Gets the current file size
EFsFileSetSize, ///< Sets the file size
EFsFileAtt, ///< Gets the file's attributes
EFsFileSetAtt, ///< Sets or clears file attributes
EFsFileModified, ///< Gets local date and time the file was last modified
EFsFileSetModified, ///< Sets the date and time the file was last modified
EFsFileSet, ///< Sets the file’s attributes, last modification date/time
EFsFileChangeMode, ///< Switches an open file's access mode
EFsFileRename, ///< Renames a file
EFsDirOpen, ///< Opens a directory
EFsDirReadOne, ///< -- 50 Reads a single directory entry
EFsDirReadPacked, ///< Reads all filtered directory entries
EFsFormatOpen, ///< Opens a device for formatting
EFsFormatNext, ///< Executes the next format step
EFsRawDiskOpen, ///< Opens a direct access channel to the disk */
EFsRawDiskRead, ///< Reads directly from the disk
EFsRawDiskWrite, ///< Writes directly to the disk
EFsResourceCountMarkStart, ///< Marks the start of resource count checking
EFsResourceCountMarkEnd, ///< Ends resource count checking
EFsResourceCount, ///< Gets the number of currently open resources
EFsCheckDisk, ///< -- 60 Checks the integrity of the disk on the specified drive
EFsGetShortName, ///< Gets the short filename
EFsGetLongName, ///< Gets the long filename
EFsIsFileOpen, ///< Tests whether a file is open
EFsListOpenFiles, ///< get a list of open files */
EFsGetNotifyUser, ///< Tests user notification of file access failure is in effect
EFsSetNotifyUser, ///< Sets if the user should be notified of file access failure
EFsIsFileInRom, ///< Gets a pointer to the specified file, if it is in ROM
EFsIsValidName, ///< Tests whether a filename and path are syntactically correct
EFsDebugFunction, ///< Different debugging info
EFsReadFileSection, ///< -- 70 Reads data from a file without opening it
EFsNotifyChangeEx, ///< Requests a notification of change to files or directories
EFsNotifyChangeCancelEx, ///< Cancels all outstanding requests for notification of change
EFsDismountFileSystem, ///< Dismounts the file system from the specified drive
EFsFileSystemName, ///< Gets the name of the file system mounted on the specified drive
EFsScanDrive, ///< Checks the specified drive for specific errors and corrects them
EFsControlIo, ///< General purpose test interface
EFsLockDrive, ///< Locks a MultiMedia card in the specified drive
EFsUnlockDrive, ///< Unlocks the MultiMedia card in the specified drive
EFsClearPassword, ///< Clears the password from the locked MultiMedia card
EFsNotifyDiskSpace, ///< -- 80 Disk space change notification
EFsNotifyDiskSpaceCancel, ///< Cancels a specific outstanding notification
EFsFileDrive, ///< Gets drive information on which this file resides
EFsRemountDrive, ///< Forces a remount of the specified drive
EFsMountFileSystemScan, ///< Mounts a file system and performs a scan on a drive
EFsSessionToPrivate, ///< Sets the session path to point to the private path
EFsPrivatePath, ///< Creates the text defining the private path
EFsCreatePrivatePath, ///< Creates the private path for a process
EFsAddExtension, ///< Adds the specified extension
EFsMountExtension, ///< Mounts the the specified extension
EFsDismountExtension, ///< -- 90 Dismounts the specified extension
EFsRemoveExtension, ///< Removes the specified extension
EFsExtensionName, ///< Gets the name of the extension on the specified drive
EFsStartupInitComplete, ///< Noifies the file server of startup initialisation completion
EFsSetLocalDriveMapping, ///< Set the local drive mapping
EFsFinaliseDrive, ///< Finalise a specific drive
EFsFileDuplicate, ///< Makes a duplicate of this file handle
EFsFileAdopt, ///< Adopts an already open file
EFsSwapFileSystem, ///< Swaps file systems
EFsErasePassword, ///< Erase the password from the locked MultiMedia card
EFsReserveDriveSpace, ///< -- 100 Reserves an area of a drive
EFsGetReserveAccess, ///< Get exclusive access to reserved area
EFsReleaseReserveAccess, ///< Release exclusive access to reserved area
EFsFileName, ///< Gets the final part of a filename
EFsGetMediaSerialNumber, ///< Gets the serial number of media
EFsFileFullName, ///< Gets the full filename
EFsAddPlugin, ///< Adds the specified plugin
EFsRemovePlugin, ///< Removes the specified plugin
EFsMountPlugin, ///< Mounts the specified plugin
EFsDismountPlugin, ///< Dismounts the specified plugin
EFsPluginName, ///<-- 110 Gets a plugin's name in specific position and drive
EFsPluginOpen, ///< Opens the plugin
EFsPluginSubClose, ///< Closes the plugin
EFsPluginDoRequest, ///< Issues an asynchronous plugin request
EFsPluginDoControl, ///< Issues a synchronous plugin request
EFsPluginDoCancel, ///< Cancels an synchronous plugin request
EFsNotifyDismount, ///< Issues a request to asynchronously dismount the file system
EFsNotifyDismountCancel, ///< Cancels a request to asynchronously dismount the file system
EFsAllowDismount, ///< Notifies that it is safe to dismount the file system
EFsSetStartupConfiguration, ///< Configures file server at startup
EFsFileReadCancel, ///< -- 120 Cancels an outstanding asynchronous read request
EFsAddCompositeMount, ///< Add a mount to the composite file system
EFsSetSessionFlags, ///< Set/Clear session specific flags
EFsSetSystemDrive, ///< Set SystemDrive
EFsBlockMap, ///< Fetches the BlockMap of a file
EFsUnclamp, ///< Re-enable modification of a specified file in storage media
EFsFileClamp, ///< Disable modification of a specified file in storage media
EFsQueryVolumeInfoExt, ///< Query interface to retrieve extended volume information
EFsInitialisePropertiesFile,///< Read in the F32 properties file provided by ESTART
EFsFileWriteDirty, ///< Writes dirty data to disk. Used when write caching enabled
EFsSynchroniseDriveThread, ///< -- 130 Synchronises the asynchronous operation which executes in driver thread
EFsAddProxyDrive, ///< Loads a proxy drive
EFsRemoveProxyDrive, ///< Unloads a proxy drive
EFsMountProxyDrive, ///< Mounts a proxy drive
EFsDismountProxyDrive, ///< Dismounts a proxy drive
EFsNotificationOpen, ///< Opens the notification
EFsNotificationBuffer, ///< Communicates buffer to file server
EFsNotificationRequest, ///< Sends the notification request
EFsNotificationCancel, ///< Cancels the notification request
EFsNotificationSubClose, ///< Closes the notification
EFsNotificationAdd, ///< -- 140 Adds filter to the server, comprising a path and notification type
EFsNotificationRemove, ///< Removes filters from Server-Side
EFsLoadCodePage, ///< Loads a code page library
EMaxClientOperations ///< This must always be the last operation insert above
};
class CFsRequest;
/**
Request wrapper for plugins
*/
class TFsPluginRequest
{
public:
/**
@publishedPartner
@released
Used for getting parameters from
a CFsRequest by a F32 plugin.
*/
enum TF32ArgType
{
EPosition,
ELength,
EData,
ESize,
EName,
ENewName,
EEntry,
ETime,
ESetAtt,
EClearAtt,
EMode,
EAtt,
EAttMask,
EUid,
EEntryArray,
ENewPosition,
EVolumeInfo
};
IMPORT_C TFsPluginRequest(CFsRequest* aRequest);
/**
@publishedPartner
@released
Get the current Function number, as defined in TFsMessage
*/
IMPORT_C TInt Function() const;
/**
@publishedPartner
@released
Returns the drive number of the current request
*/
IMPORT_C TInt DriveNumber() const;
IMPORT_C TParse& Src() const;
IMPORT_C TParse& Dest() const;
IMPORT_C TDrive* Drive() const;
IMPORT_C TDrive* SubstedDrive() const;
IMPORT_C const RMessage2& Message() const;
IMPORT_C CFsRequest* Request() const;
IMPORT_C TUint ScratchValue() const;
IMPORT_C TInt64 ScratchValue64() const;
IMPORT_C TBool IsPostOperation() const;
/**
@publishedPartner
@released
Utility function for returning a TInt type of TF32ArgType value from the current request.
i.e. ELength.
To obtain EPosition, authors should use ::Read(TF32ArgType,TInt64&)
*/
IMPORT_C TInt Read(TF32ArgType aType, TInt& aVal);
/**
@publishedPartner
@released
Utility function for returning a TUint type of TF32ArgType value from the current request.
To obtain EPosition, authors should use ::Read(TF32ArgType,TInt64&)
*/
IMPORT_C TInt Read(TF32ArgType aType, TUint& aVal);
/**
@publishedPartner
@released
Utility function for returning a TInt64 type of TF32ArgType value from the current request.
i.e. EPosition.
*/
IMPORT_C TInt Read(TF32ArgType aType, TInt64& aVal);
/**
@publishedPartner
@released
Utility function for receving descriptor or packaged paramters of the current request.
For non-descriptor types such a TEntry, plugin authors should pass an object of type TPckg<TEntry> in to aDes.
*/
IMPORT_C TInt Read(TF32ArgType aType, TDes8& aDes, TInt aOffset = 0);
/**
@publishedPartner
@released
Utility function for receving descriptor or packaged paramters of the current request.
For non-descriptor types such a TEntry, plugin authors should pass an object of type TPckg<TEntry> in to aDes.
*/
IMPORT_C TInt Read(TF32ArgType aType, TDes16& aDes, TInt aOffset = 0);
/**
@publishedPartner
@released
Utilty function for writing data back to the request.
Non-descriptor values should be packaged i.e TPckg<TUidType>
*/
IMPORT_C TInt Write(TF32ArgType aType, const TDesC8& aDes, TInt aOffset = 0);
/**
@publishedPartner
@released
Utilty function for writing data back to the request.
Non-descriptor values should be packaged i.e TPckg<TUidType>
*/
IMPORT_C TInt Write(TF32ArgType aType, const TDesC16& aDes, TInt aOffset = 0);
/**
@publishedPartner
@released
*/
IMPORT_C TInt FileName(TDes& aName);
/**
@publishedPartner
@released
When plugin authors perform early completion of read or write requests, then SetSharePos should be called in order to
update the share position to the client.
*/
IMPORT_C TInt SetSharePos(TInt64& aPos);
private:
TInt ClientSubSessionHandle(TInt& aHandle);
TInt ShareFromClientHandle(CFileShare*& aShare);
void NameFromShare(CFileShare& aFileShare, TDes& aName);
private:
CFsRequest* iFsRequest;
friend class RFilePlugin;
};
/**
@publishedPartner
@released
Helper class for plugins to use to access TEntryArray data
*/
class TRawEntryArray : public TEntryArray
{
public:
IMPORT_C TDes8& Buf();
IMPORT_C void SetBuf(TDes8& aBuf);
IMPORT_C TInt EntrySize(TInt aIdx);
};
class CFsPlugin;
class CPluginThread;
class CFsPluginConn;
/**
Plugin factory class. It is created when RFs::AddPlugin is called.
*/
class CFsPluginFactory : public CFsObject
{
public:
IMPORT_C CFsPluginFactory();
IMPORT_C ~CFsPluginFactory();
IMPORT_C virtual TInt Remove();
IMPORT_C void SetLibrary(RLibrary aLib);
IMPORT_C RLibrary Library() const;
public:
/**
@internalTechnology
Installs the plugin factory
@return KErrNone or one of the system wide errors
*/
virtual TInt Install()=0;
/**
@internalTechnology
Creates a new plugin
@return plugin object
*/
virtual CFsPlugin* NewPluginL()=0;
/**
@internalTechnology
Returns unique position of the plugin
@return unique position of the plugin
*/
virtual TInt UniquePosition()=0;
public:
TBool IsDriveSupported(TInt aDrive);
inline TInt MountedPlugins();
inline TInt SupportedDrives(); //aSupportedDrives is a bit mask
private:
inline void IncrementMounted();
inline void DecrementMounted();
protected:
TInt iSupportedDrives;
inline void SetSupportedDrives(TInt aSupportedDrives); //aSupportedDrives is a bit mask
private:
TInt iMountedPlugins;
TInt iUniquePos;
RLibrary iLibrary;
friend class FsPluginManager;
};
/**
A base class for File Server Plugins
*/
class CFsPlugin : public CFsObject
{
protected:
/** Intercept attribute to specify the order of request handling */
enum TInterceptAtts
{
EPreIntercept = 0x01, ///< handles the request before the next plugin in chain
EPostIntercept = 0x02, ///< handles the request after the next plugin in chain
EPrePostIntercept = EPreIntercept | EPostIntercept ///< covers both pre and post intercept
};
public:
IMPORT_C CFsPlugin();
IMPORT_C ~CFsPlugin();
inline TInt Drive();
inline void SetDrive(TInt aDrive);
inline virtual TInt SessionDisconnect(CSessionFs* aSession);
protected:
IMPORT_C virtual void InitialiseL();
IMPORT_C virtual TInt Deliver(TFsPluginRequest& aRequest);
virtual TInt DoRequestL(TFsPluginRequest& aRequest) = 0;
IMPORT_C virtual CFsPluginConn* NewPluginConnL();
IMPORT_C TInt RegisterIntercept(TInt aMessage, TInterceptAtts aInterceptAtts);
IMPORT_C TInt UnregisterIntercept(TInt aMessage, TInterceptAtts aInterceptAtts);
/** @prototype */
IMPORT_C TInt FileRead(TFsPluginRequest& aRequest, TDes8& aDes, TInt64 aPos);
IMPORT_C TInt FileWrite(TFsPluginRequest& aRequest, const TDesC8& aDes, TInt64 aPos);
IMPORT_C static TInt ClientRead(TFsPluginRequest& aRequest, TDes8& aDes,TInt aOffset=0);
IMPORT_C static TInt ClientWrite(TFsPluginRequest& aRequest, const TDesC8& aDes,TInt aOffset=0);
//Overloaded function - checks all types of TInterceptAtts
TBool IsRegistered(TInt aMessage);
TBool IsRegistered(TInt aMessage, TInterceptAtts aInterceptAtts);
TBool IsPluginThread(CFsRequest& aMessage);
TBool IsMounted(TInt aDrive);
private:
TInt DispatchOperation(TFsPluginRequest& aRequest, TDes8& aDes, TInt64 aPos, TInt aFunction);
static TInt Complete(CFsRequest* aRequest, TInt aError);
static TInt Complete(CFsRequest* aRequest);
TInt WaitForRequest();
protected:
TThreadId iThreadId;
private:
CPluginThread* iThreadP;
TInt iDrive;
/**
The remaining space in this base class in release 9.1 is defined as follows:
TUint8 iRegisteredIntercepts[EMaxClientOperations << 1]; 244 bytes
TInt iUniquePos; 4 bytes
TOTAL 248 bytes
where EMaxClientOperations = 122.
Unfortunately, the remaining space in release 9.2+ WAS defined as follows:
enum {KIntcArrSize = 123*2};
TUint8 iRegisteredIntercepts[KIntcArrSize]; 246 bytes
2 bytes (padding)
TInt iUniquePos; 4 bytes
TOTAL: 252 bytes
This meant that a 9.1-compiled plugin running on 9.2+ would have its first data
member overwritten when the base class (CFsPlugin) wrote to iUniquePos.
To maintain Binary Compatibility (BC), we need to preserve both the (smaller) 9.1
and (larger) 9.2+ class sizes.
To allow 9.1 plugins to work unchanged on 9.2+ iUniquePos has been moved to BEFORE
the iRegisteredIntercepts byte array
N.B. - the iRegisteredIntercepts array uses only 2 bits per function, so the
array size only needs to be >= EMaxClientOperations/4.
*/
enum {KIntcArrSize = 132};
TInt iUniquePos; // 4 bytes
TUint8 iRegisteredIntercepts[KIntcArrSize]; // 132 bytes
TInt iLastError; // 4 bytes
TInt iMountedOn; //bitmask // 4 bytes
TUint iSpare[26]; // 104 bytes
// extra 4 bytes to preserve BC with 9.1 plugins. Don't move !
const TUint iReadOnly; // 4 bytes
// TOTAL: 252
friend class FsPluginManager;
friend class CFsRequest;
friend class CFsMessageRequest;
friend class CFsInternalRequest;
friend class CPluginThread;
friend class TFsDismountPlugin;
friend class TPluginSessionHelper;
friend class TFsDirOpen; //For access to TInterceptAtts
};
class TPluginSessionHelper
{
public:
TPluginSessionHelper();
TPluginSessionHelper(TFsPluginRequest* aRequest, TBool aDirectToDrive);
TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs, TInt* aReply);
TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs) const;
TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs, TInt aSubSessionHandle) const;
inline TFsPluginRequest* Request();
private:
TInt Dispatch(TInt aFunction, TIpcArgs& aArgs) const;
private:
CFsPlugin* iPlugin; // owner; used for setting iCurrentPlugin in CFsMessageRequest
CSessionFs* iSession;
RLocalMessage iMessage;
TBool iDirectToDrive;
TFsPluginRequest* iRequest;
TUint iSpare[4];
};
/**
A class for making file server request internally from within a
file server plugin.
See also RFilePlugin and RDirPlugin.
@publishedPartner
@released
*/
class RFsPlugin : private RFs
{
public:
IMPORT_C RFsPlugin(TFsPluginRequest& aRequest, TBool aDirectToDrive = EFalse);
IMPORT_C ~RFsPlugin();
IMPORT_C TInt Connect();
IMPORT_C void Close();
IMPORT_C TInt Delete(const TDesC& aName);
IMPORT_C TInt Rename(const TDesC& anOldName,const TDesC& aNewName);
IMPORT_C TInt Replace(const TDesC& anOldName,const TDesC& aNewName);
IMPORT_C TInt Entry(const TDesC& aName,TEntry& anEntry) const;
IMPORT_C TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);
IMPORT_C TInt ReadFileSection(const TDesC& aName,TInt64 aPos,TDes8& aDes,TInt aLength) const;
IMPORT_C TInt Volume(TVolumeInfo &aVol,TInt aDrive=KDefaultDrive) const;
protected:
TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
private:
RFsPlugin();
RFsPlugin(const RFsPlugin&);
RFsPlugin& operator=(const RFsPlugin&);
void SetHandle(TInt aHandle);
private:
TPluginSessionHelper iSessionHelper;
friend class RFs;
};
/**
@publishedPartner
@released
*/
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
class RFilePlugin : private RFile
#else
class RFilePlugin : private RFile64
#endif
{
public:
IMPORT_C RFilePlugin(TFsPluginRequest& aRequest, TBool aDirectToDrive = EFalse);
IMPORT_C ~RFilePlugin();
// open a NEW file using same session as passed request
IMPORT_C TInt Open(const TDesC& aName,TUint aMode);
IMPORT_C TInt Create(const TDesC& aName,TUint aFileMode);
IMPORT_C TInt Replace(const TDesC& aName,TUint aFileMode);
IMPORT_C TInt Temp(const TDesC& aPath,TFileName& aName,TUint aFileMode);
// re-open SAME file as client's request
IMPORT_C TInt AdoptFromClient();
// Transfer the plugin's open file to the client
IMPORT_C TInt TransferToClient();
IMPORT_C void Close();
// RFile overloads
IMPORT_C TInt Read(TInt64 aPos,TDes8& aDes) const;
IMPORT_C TInt Read(TInt64 aPos,TDes8& aDes,TInt aLength) const;
IMPORT_C TInt Write(TInt64 aPos,const TDesC8& aDes);
IMPORT_C TInt Write(TInt64 aPos,const TDesC8& aDes,TInt aLength);
IMPORT_C TInt Lock(TInt64 aPos,TInt64 aLength) const;
IMPORT_C TInt UnLock(TInt64 aPos,TInt64 aLength) const;
IMPORT_C TInt Seek(TSeek aMode,TInt64& aPos) const;
IMPORT_C TInt Flush();
IMPORT_C TInt Size(TInt64& aSize) const;
IMPORT_C TInt SetSize(TInt64 aSize);
IMPORT_C TInt Att(TUint& aAttValue) const;
IMPORT_C TInt SetAtt(TUint aSetAttMask,TUint aClearAttMask);
IMPORT_C TInt Modified(TTime& aTime) const;
IMPORT_C TInt SetModified(const TTime& aTime);
IMPORT_C TInt Set(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);
IMPORT_C TInt ChangeMode(TFileMode aNewMode);
IMPORT_C TInt Rename(const TDesC& aNewName);
protected:
// RSubSessionBase overrides
TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
void CloseSubSession(TInt aFunction);
private:
RFilePlugin();
RFilePlugin(const RFilePlugin&);
RFilePlugin& operator=(const RFilePlugin&);
void SetHandle(TInt aHandle);
void SetSubSessionHandle(TInt aHandle);
private:
TPluginSessionHelper iSessionHelper;
friend class RFile;
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
friend class RFile64;
#endif
};
/**
@publishedPartner
@released
*/
class RDirPlugin : private RDir
{
public:
IMPORT_C RDirPlugin(TFsPluginRequest& aRequest, TBool aDirectToDrive = EFalse);
IMPORT_C ~RDirPlugin();
IMPORT_C TInt Open(const TDesC& aMatchName,const TUidType& aUidType);
IMPORT_C TInt Open(const TDesC& aMatchName,TUint anAttMask);
IMPORT_C void Close();
/**
Plugin authors should pass in a TRawEntryArray if their intent is to modify the data.
*/
IMPORT_C TInt Read(TEntryArray& aArray);
IMPORT_C TInt Read(TEntry& aEntry);
protected:
// RSubSessionBase overrides
TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
void CloseSubSession(TInt aFunction);
private:
RDirPlugin();
RDirPlugin(const RDirPlugin&);
RDirPlugin& operator=(const RDirPlugin&);
void SetHandle(TInt aHandle);
void SetSubSessionHandle(TInt aHandle);
private:
TPluginSessionHelper iSessionHelper;
friend class RDir;
};
class CFsRequest;
class CFsPluginConnRequest : public CBase
{
public:
CFsPluginConnRequest(CFsPluginConn* aPluginConn);
public:
inline TInt Function() const;
inline TDes8* Param1() const;
inline TDes8* Param2() const;
inline void WriteParam1L(const TDesC8& aDes) const;
inline void WriteParam2L(const TDesC8& aDes) const;
inline void ReadParam1L(TDes8& aDes) const;
inline void ReadParam2L(TDes8& aDes) const;
inline const RMessagePtr2& Message() const;
public:
TInt DoControl();
void DoRequest();
inline void Complete(TInt aError);
public:
TInt InitControl(CFsRequest* aRequest);
TInt InitRequest(CFsRequest* aRequest);
private:
TDblQueLink iLink;
CFsPluginConn& iPluginConn;
TInt iFunction;
TDes8* iParam1;
TDes8* iParam2;
public:
RMessagePtr2 iMessage;
friend class TPluginConnRequestQue;
friend class CFsPluginConn;
};
class TPluginConnRequestQue
{
public:
TPluginConnRequestQue();
~TPluginConnRequestQue();
void DoAddRequest(CFsPluginConnRequest* aRequest);
IMPORT_C void DoCancelAll(TInt aCompletionCode);
protected:
TDblQue<CFsPluginConnRequest> iHeader;
};
/**
Plugin connection object
*/
class CFsPluginConn : public CFsObject
{
public:
IMPORT_C CFsPluginConn();
IMPORT_C ~CFsPluginConn();
virtual TInt DoControl(CFsPluginConnRequest& aRequest) = 0;
virtual void DoRequest(CFsPluginConnRequest& aRequest) = 0;
virtual void DoCancel(TInt aReqMask) = 0;
inline CFsPlugin* Plugin() const;
inline TThreadId ClientId() const;
private:
IMPORT_C void Close();
CFsPlugin* iPluginP;
TThreadId iClientId;
public:
TPluginConnRequestQue iRequestQue;
friend class FsPluginManager;
};
#include <f32plugin.inl>
#endif // __F32PLUGIN_H