diff -r 000000000000 -r d0791faffa3f backupandrestore/backupengine/inc/javamanagerinterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/backupandrestore/backupengine/inc/javamanagerinterface.h Tue Feb 02 01:11:40 2010 +0200 @@ -0,0 +1,204 @@ +/** +* Copyright (c) 2004-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: +* Declaration of CJavaManagerInterface +* +* +*/ + + + +/** + @file +*/ +#ifndef __JAVAMANAGERINTERFACE_H__ +#define __JAVAMANAGERINTERFACE_H__ + +// System +#include +#include +#include + +#include + +/* +@KJavaManagerInterfaceUid, Ther JavaMangerInterface Uid. +This UID is used by the implementer of the ThirdPartyJavaManager plugin. +This plugin is used in Backup and restore engine. +*/ +const TUid KJavaManagerInterfaceUid = { 0x2000D924 }; + +namespace conn + { + + class CDataOwnerInfo; + class CSBGenericTransferType; + class CSBGenericDataType; +/** +Clients creating a java backup and restore plugin should derive from and implement this interface. +@publishedPartner +@released +*/ + class CJavaManagerInterface : public CBase + { + + public: + + /** + static function to create and return the object. + + @return CJavaManagerInterface* Pointer to newly instantiated object. + */ + inline static CJavaManagerInterface* NewL( const TUid& aImplementationUid ); + + /** + Destructor. + + */ + inline virtual ~CJavaManagerInterface(); + + + public: + + /** + Method requesting information about all of the Java data owners that are represented by this object + @param aDataOwners Array of data owner info's to populate + */ + virtual void GetDataOwnersL(RPointerArray& aDataOwners)=0; + /** + Return the expected size of data to be returned to the PC client. Used for displaying progress information + @param aGenericTransferType The type of data that the expected size is being requested for + @param aSize Stores the expected size value to be returned to the PC side client + */ + virtual void GetExpectedDataSizeL(CSBGenericTransferType* aGenericTransferType, TUint& aSize)=0; + + /** + Get a list of public files that the java data owners are requesting to be backed up in addition to their + own private data stores + @param aDriveNumber The drive that these public files are being requested for + @param aFiles An array of filenames that will be populated upon return of this method + */ + virtual void GetPublicFileListL(CSBGenericDataType* aGenericDataType, TDriveNumber aDriveNumber, RFileArray& aFiles)=0; + + /** + Get a list of public files that the java data owners are requesting to be backed up in addition to their + own private data stores + @param aDriveNumber The drive that these public files are being requested for + @param aFiles An array of filenames that will be populated upon return of this method + */ + virtual void GetRawPublicFileListL(CSBGenericDataType* aGenericDataType, TDriveNumber aDriveNumber, RRestoreFileFilterArray& aFileFilter)=0; + + /** + Supplies data to the particular data owners to process + @param aGenericTransferType The type of data that's being supplied + @param aBuffer Buffer containing the data to be supplied + @param aFinished Flag determining whether or not this buffer is the last in a multipart sequence + */ + virtual void SupplyDataL(CSBGenericTransferType* aGenericTransferType, TDesC8& aBuffer, TBool aFinished)=0; + + /** + Request a type of data from a particular data owner + @param aGenericTransferType The type of data being requested + @param aBuffer The buffer to populate with data + @param aFinished Flag to be set depending on whether another request is required to transfer + all of this data owner's data + */ + virtual void RequestDataL(CSBGenericTransferType* aGenericTransferType, TPtr8& aBuffer, TBool& aFinished)=0; + + /** + Called by the PC client once all registration and binary files have been restored. Used as a signal to + indicate that the next set of transfers will include data + */ + virtual void AllSystemFilesRestored()=0; + /** + Method to check the data type of the file + @param TDesC& aFileName File name of the file to recognize + @return TDataRecognitionResult Data Recognized Result + */ + virtual TDataRecognitionResult RecognizeDataTypeL(const TDesC& aFileName)=0; + /** + Returns the handle to File Server. + */ + + virtual RFs& GetRFs()=0; + + /** Returns a pointer to a specified interface extension - to allow future extension + of this class without breaking binary compatibility + + @param aInterfaceUid Identifier of the interface to be retrieved + @param aInterface A reference to a pointer that retrieves the specified interface. + */ + virtual void GetExtendedInterface(TUid aInterfaceUid, TAny*& aInterface)=0; + + protected: + /** + Scan the SystemAMS data cage (private directory) for all registration files corresponding to installed MIDlet's + @param aRegFileArray Array of registration files that will be populated with all reg files in the SystemAMS data cage + **/ + virtual void ScanForRegistrationFilesL(RFileArray& aRegFileArray)=0; + + /** + Tries Parsing the Java Data Owner at runtime. + @param aFileName aSuiteHash the suite hash of the java data owner + */ + virtual void ParseJavaDataOwnerL(const TDesC& aSuiteHash)=0; + + + protected: + + /** + * Constructor. + */ + inline CJavaManagerInterface(); + + private: + TUid iDtor_ID_Key; //ECOM Plugin identifier + + }; + + /** + * Template classes to call ResetAndDestroy on array classes + * automatically, when ::PopAndDestroy'ing from the cleanup stack. + */ + template + class CleanupResetAndDestroy + { + public: + inline static void PushL(T& aRef); + private: + static void ResetAndDestroy(TAny *aPtr); + }; + template + inline void CleanupResetAndDestroyL(T& aRef); + + // Template class CleanupClose + template + inline void CleanupResetAndDestroy::PushL(T& aRef) + {CleanupStack::PushL(TCleanupItem(&ResetAndDestroy, &aRef));} + template + void CleanupResetAndDestroy::ResetAndDestroy(TAny *aPtr) + {static_cast(aPtr)->ResetAndDestroy();} + template + inline void CleanupResetAndDestroyPushL(T& aRef) + {CleanupResetAndDestroy::PushL(aRef);} + + + #include + + + }// namespace conn + + + +#endif // __JAVAMANAGERINTERFACE_H__