/**
* 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 <e32base.h>
#include <ecom/ecom.h>
#include <apmrec.h>
#include <connect/sbtypes.h>
/*
@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<CDataOwnerInfo>& 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 T>
class CleanupResetAndDestroy
{
public:
inline static void PushL(T& aRef);
private:
static void ResetAndDestroy(TAny *aPtr);
};
template <class T>
inline void CleanupResetAndDestroyL(T& aRef);
// Template class CleanupClose
template <class T>
inline void CleanupResetAndDestroy<T>::PushL(T& aRef)
{CleanupStack::PushL(TCleanupItem(&ResetAndDestroy, &aRef));}
template <class T>
void CleanupResetAndDestroy<T>::ResetAndDestroy(TAny *aPtr)
{static_cast<T*>(aPtr)->ResetAndDestroy();}
template <class T>
inline void CleanupResetAndDestroyPushL(T& aRef)
{CleanupResetAndDestroy<T>::PushL(aRef);}
#include <connect/javamanagerinterface.inl>
}// namespace conn
#endif // __JAVAMANAGERINTERFACE_H__