--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsconnection/inc/senserviceconnectionimpl.h Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,636 @@
+/*
+* Copyright (c) 2002-2005 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: Custom plug-in implementations offer their own API documentation
+* where detailed characteristics about how methods declared in this
+* class are implemented.
+*
+*/
+
+
+
+
+
+
+
+
+#ifndef SEN_SERVICE_CONNECTION_IMPL_H
+#define SEN_SERVICE_CONNECTION_IMPL_H
+
+// INCLUDES
+#include <flogger.h>
+#include <e32property.h>
+
+#include "sendebug.h"
+
+#include "SenServiceConnection.h"
+#ifdef __ENABLE_ALR__
+ #include "senserviceconnectioninterfaces.h"
+#endif //__ENABLE_ALR__
+#include "seninternalserviceconnectioninterfaces.h"
+
+#include "MSenServiceDescription.h"
+#include "rsenserviceconnection.h"
+#include "senpointermap.h"
+#include "SenHttpTransportProperties.h"
+
+#include "msencobrandinginterface.h"
+
+#include "senservicedispatcher.h"
+#include "senregistrationtimer.h"
+
+// CONSTANTS
+_LIT8(KServiceConnectionElementLocalName, "ServiceConnection");
+
+// FORWARD DECLARATIONS
+class CSenConnectionChunk;
+class CSenAsyncOperation;
+class CSenConnectionStatusObserver;
+class CSenFileProgressObserver;
+class CSenBinaryContainer;
+class RProperty;
+
+// TYPEDEFS
+typedef RSenPointerMap<TInt, CSenConnectionChunk> RChunkMap;
+typedef RSenPointerMap<TDesC8, CSenBinaryContainer> RBinaryMap;
+typedef RArray<TXmlEngDataContainer> RDataContainerArray;
+typedef RSenPointerMap<TInt, RDataContainerArray> RDataContainerMap;
+
+// CLASS DECLARATION
+
+/**
+* Custom plug-in implementations offer their own API documentation
+* where detailed characteristics about how methods declared in this
+* class are implemented.
+*/
+#ifdef __ENABLE_ALR__
+ class CSenServiceConnectionImpl : public CSenServiceConnection, MSenInternalServiceConnection, MSenAlrServiceConnection, MSenRegistrationActor
+#else
+ class CSenServiceConnectionImpl : public CSenServiceConnection, MSenInternalServiceConnection, MSenRegistrationActor
+#endif //__ENABLE_ALR__
+ {
+ friend class CSenAsyncOperation;
+ friend class CSenUnderTakerWaiter;
+ public:
+
+ // Constructors and destructor:
+ static CSenServiceConnectionImpl* NewL(MSenServiceConsumer& aObserver,
+ const TDesC8& aUri);
+
+ static CSenServiceConnectionImpl* NewLC(MSenServiceConsumer& aObserver,
+ const TDesC8& aUri);
+
+ static CSenServiceConnectionImpl* NewL(MSenServiceConsumer& aObserver,
+ MSenServiceDescription& aServiceDescription);
+
+ static CSenServiceConnectionImpl* NewLC(MSenServiceConsumer& aObserver,
+ MSenServiceDescription& aServiceDescription);
+
+ static CSenServiceConnectionImpl* NewL(MSenServiceConsumer& aObserver,
+ CSenServicePattern& aServicePattern);
+
+ static CSenServiceConnectionImpl* NewLC(MSenServiceConsumer& aObserver,
+ CSenServicePattern& aServicePattern);
+
+ static CSenServiceConnectionImpl* NewL(MSenServiceConsumer& aConsumer,
+ const TDesC8& aContract,
+ MSenExtendedConsumerInterface& aExtendedConsumer);
+
+ static CSenServiceConnectionImpl* NewLC(MSenServiceConsumer& aConsumer,
+ const TDesC8& aContract,
+ MSenExtendedConsumerInterface& aExtendedConsumer);
+
+ static CSenServiceConnectionImpl* NewL(MSenServiceConsumer& aConsumer,
+ MSenServiceDescription& aServiceDescription,
+ MSenExtendedConsumerInterface& aExtendedConsumer);
+
+ static CSenServiceConnectionImpl* NewLC(MSenServiceConsumer& aConsumer,
+ MSenServiceDescription& aServiceDescription,
+ MSenExtendedConsumerInterface& aExtendedConsumer);
+
+ static CSenServiceConnectionImpl* NewL(MSenServiceConsumer& aConsumer,
+ CSenServicePattern& aServicePattern,
+ MSenExtendedConsumerInterface& aExtendedConsumer);
+
+ static CSenServiceConnectionImpl* NewLC(MSenServiceConsumer& aConsumer,
+ CSenServicePattern& aServicePattern,
+ MSenExtendedConsumerInterface& aExtendedConsumer);
+ // Opens connection to WSF Symbian Server
+ void ConnectL();
+
+ void SetConsumer( MSenServiceConsumer& aConsumer, MSenExtendedConsumerInterface* apExtConsumer = NULL );
+ void Consumer( MSenServiceConsumer*& aConsumer, MSenExtendedConsumerInterface*& apExtConsumer );
+
+ virtual ~CSenServiceConnectionImpl();
+
+ // New functions:
+ virtual TInt SendL(const TDesC8& aRequest);
+ virtual TInt SubmitL(const TDesC8& aRequest, HBufC8*& aResponse);
+ virtual TInt CompleteServerMessagesOnOff(const TBool& aCompleteOnOff);
+ virtual TInt HasFacetL(const TDesC8& aURI, TBool& aHasFacet);
+ virtual TInt IsReady(TBool& aReady);
+ virtual TInt SendL(RFile& aFile);
+ virtual TInt SubmitL(RFile& aFileHandle, HBufC8*& aResponse);
+// virtual TBool IsServChunkSlotAvailable();
+ virtual TInt SendL(CSenSoapEnvelope& aMessage);
+ virtual TInt SubmitL(CSenSoapEnvelope& aMessage, HBufC8*& aResponseTo);
+
+ virtual TInt ServiceDescriptionL(HBufC8*& aServiceDescription);
+ virtual TInt StartTransaction();
+ virtual TInt TransactionCompleted();
+ virtual TInt CancelAllRequests();
+
+ virtual void WriteStartElementL( const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName,
+ const RAttributeArray& aAttributes);
+
+ virtual void WriteEndElementL(const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName);
+
+ virtual const TDesC8& LocalName() const;
+ virtual const TDesC8& NsUri() const;
+ virtual const TDesC8& NsPrefix() const;
+ virtual void WriteAsXMLToL(RWriteStream& aWriteStream);
+ virtual HBufC* AsXmlUnicodeL();
+ virtual HBufC8* AsXmlL();
+ virtual TBool ConsistsOfL(MSenFragment& aCandidate);
+
+ // Functions from base classes
+
+ // from MSenFragment
+ /**
+ * @return the current object as element.
+ * Retains ownership.
+ */
+ virtual CSenElement& AsElement();
+
+ /**
+ * @return the current object as element. May return NULL.
+ * Caller takes ownership.
+ */
+ virtual CSenElement* ExtractElement();
+
+ virtual void SetReader(CSenXmlReader& aReader);
+ virtual CSenXmlReader* Reader();
+
+ /**
+ * SetReader() must be called before this method can be used.
+ */
+ virtual void ParseL(const TDesC8& aBuf);
+
+ /**
+ * Same as ParseL() except that it takes 16-bit input and does silently
+ * fail in case of all errors.
+ * SetReader() must be called before this method can be used.
+ * @return error code, if any.
+ */
+ virtual TInt BuildFrom(const TDesC8& aBuf);
+
+ /**
+ * Let the delegate CSenFragment handle with SAX events.
+ * "this" CSenFragment is made the owner of the delegate and
+ * the delegate is expected to make this CSenFragment the receiver
+ * of SAX events once it has seen the end element for itself.
+ */
+ virtual void DelegateParsingL(MSenFragment& aDelegate);
+
+ /**
+ * Let a new CSenFragment for a new CSenBaseElement with the given
+ * namespace and name handle SAX events. The new MSenElement is made
+ * a child of the MSenElement of this CSenFragment.
+ */
+ virtual void DelegateParsingL( const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName,
+ const RAttributeArray& aAttributes);
+
+ virtual void ParseWithL(CSenXmlReader& aReader);
+ virtual void SetOwner(MSenFragment& aFragment);
+ virtual void ResumeParsingFromL( const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName );
+
+ virtual void SetAttributesL(const RAttributeArray& aAttributes);
+ virtual TInt TxnId();
+ virtual MSenMessage* Response();
+ virtual TInt CancelTransaction(TInt aTransactionID);
+ virtual TInt SetTransportPropertiesL(const TDesC8& aProperties);
+ virtual TInt TransportPropertiesL(HBufC8*& aProperties);
+ virtual TInt SendL(const TDesC8& aRequest, const TDesC8& aProperties);
+ virtual TInt SendL(CSenSoapEnvelope& aMessage, const TDesC8& aProperties);
+ virtual TInt SubmitL(CSenSoapEnvelope& aMessage, const TDesC8& aProperties, HBufC8*& aResponseTo);
+ virtual TInt SubmitL(const TDesC8& aRequest, const TDesC8& aProperties, HBufC8*& aResponse);
+ virtual TInt AssignMessageToChunkL(CSenChunk& aChunk, MSenMessage& aMessage); //codescannerwarnings
+ virtual TInt SendL(MSenMessage& aMessage);
+ virtual TInt SubmitL(MSenMessage& aMessage, CSenSoapEnvelope2*& aResponseTo);
+ virtual TInt IdentityProviderL(CSenIdentityProvider*& apIdentityProvider);
+ virtual TInt Identifier();
+
+ virtual void DataTrafficDetails( TSenDataTrafficDetails& aDetails,
+ TSenDataTrafficOperations& aOperations );
+
+
+
+#ifdef __ENABLE_ALR__
+ virtual void MigrateToPrefferedCarrierL(TBool &aUserChoice) ;
+ virtual void NewCarrierAcceptedL(TBool &aUserChoice) ;
+#endif
+ virtual TInt PendingTrasanctionsCount();
+
+ // From MSenInternalServiceConnection
+ /**
+ * Sends information about BLOB transfer progres to hostlet.
+ *
+ * @param aTxnId Transaction ID.
+ * @param aIncoming ETrue if it is incoming BLOB, EFalse if outgoing.
+ * @param aMessage SOAP message for incoming messages with BLOBs.
+ * @param aCid CID of current BLOB.
+ * @param aProgress Count of sent/received BLOB bytes.
+ */
+ virtual TInt SendProgressToHostlet(TInt aTxnId, TBool aIncoming, const TDesC8& aMessage, const TDesC8& aCid, TInt aProgress);
+
+ TPtrC8 InitDescription();
+
+ protected: // Functions from base classes
+
+ // from CActive
+ void RunL();
+ void DoCancel();
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CSenServiceConnectionImpl(MSenServiceConsumer& aObserver,
+ MSenExtendedConsumerInterface* aExtendedConsumerInteface);
+
+ /**
+ * By default Symbian 2nd phase constructor is private.
+ */
+ void ConstructL(MSenServiceDescription& aPattern);
+
+ // New functions
+ TInt SendL(CSenSoapEnvelope2& aMessage);
+
+ TInt SubmitL(CSenSoapEnvelope2& aMessage, CSenSoapEnvelope2*& aResponseTo);
+
+
+ TInt SendL(CSenConnectionChunk* aClientOp);
+
+ TInt SubmitL(CSenConnectionChunk& aClientOp);
+
+ TInt ResponseFromChunk(CSenChunk& aClientOp, HBufC8*& aResponseTo);
+
+ TInt SubmitL(CSenConnectionChunk& aClientOp, CSenSoapEnvelope2*& aResponseTo);
+
+ TInt CheckConnection();
+
+ void InitializeL( /*MSenServiceDescription& aPattern */ );
+
+ void DeliverResponseL(const TInt aErrorCode, CSenChunk* apOperation = NULL);
+
+ RChunkMap& ChunkMapL();
+
+ TPtrC SessionID();
+
+ TPtrC NextChunkName();
+
+ RPointerArray<CSenAsyncOperation>& AsyncOpsArrayL(); //codescannerwarnings
+
+ void HandleMessageFromChildAOL(TInt aStatus);
+
+ TInt AssignPropertiesToChunkL(CSenChunk& aChunk, CSenSoapEnvelope& aMessage,
+ const TDesC8& aProperties = KNullDesC8); ////codescannerwarnings
+
+ TInt MoveBinaryContainersToServer(CSenConnectionChunk& aOperation,
+ RArray<TXmlEngDataContainer>& aList);
+ TInt MoveFileChunkHandleToServer(CSenConnectionChunk& aOperation);
+
+
+ RFileLogger* Log() const;
+
+ void DeliverStatus(TInt aStatus);
+
+ /*
+ * Method gets the Http method from the transport properties
+ * @param aProperties contains the transport properties in serialized (UTF-8) form.
+ * @param aMethod A TSenHttpMethod reference to be filled in with
+ * the value of the Http method.
+ * @return KErrNone if successful or otherwise some system-wide error code.
+ * KErrNotFound if Http method is not found
+ */
+ TInt HttpMethodFromPropertiesL( const TDesC8& aProperties,
+ CSenHttpTransportProperties::TSenHttpMethod& aMethod );
+
+ TInt SearchIdentityProviderL(CSenIdentityProvider*& aSenChunk, const TDesC8& aProviderId);
+ TInt RegisterAuthenticationObserver();
+ TBool HasConnectionAgentCallbackInitialized();
+ TInt ReauthNeededL(const TDesC8& aProviderId);
+ TInt RegisterFilesObserver();
+ const TThreadId OwnerThreadId() const;
+ TInt RegisterCoBrandingObserver();
+
+ TInt RegisterAndSubscribeFileProgressObserversL();
+
+ virtual TAny* InterfaceByUid( TUid aUID );
+
+
+#ifdef __ENABLE_ALR__
+ TInt RegisterMobilityObserverL() ;
+#endif
+
+ private: // Data
+ RFileLogger iLog;
+ RSenServiceConnection iConnection; // owned
+ MSenServiceConsumer* iObserver; // not owned
+ HBufC8* iInBuf; // owned
+ TPtr8 iInBuffer;
+ HBufC8* iOutBuf; // owned
+ TPtr8 iOutBuffer;
+ TBool iInitialized;
+ CSenBaseFragment* iFragment;
+ TInt iResponseLength;
+ TInt iErrorNumber;
+ TPtr8 iErrorNumberBuffer;
+ TInt iTxnId;
+ TPtr8 iTxnIdBuffer;
+
+ RChunkMap* iChunkMap;
+
+ HBufC* ipSessionId;
+ TPtr iSessionIdBuffer;
+ TInt iChunkNameNumber;
+ HBufC* ipChunkName;
+
+ TBool iTransactionIdKnown;
+ TUint iAsyncOpsCount;
+ RPointerArray<CSenAsyncOperation>* iAsyncOpsArray;
+
+ MSenMessage* iResponse;
+
+ CSenChunk* ipInitChunk; // owned
+ TBool* ipCompleteServerMsgsOnOff; // owned
+
+ CSenConnectionStatusObserver* ipConnectionStatusObserver; // owned
+ CSenFileProgressObserver* ipFileProgressObserver; // owned
+
+ TInt iConnectionID;
+ MSenFilesObserver* iFilesObserver; // connectionagent observer
+ //TInt iTlsLogChannel;
+ TInt iTlsLogStatusChannel;
+
+ HBufC8* ipInitPatternAsXml;
+ HBufC8* ipInitConsumerPolicyAsXml;
+ MSenAuthenticationProvider* ipAuthProvider; // connectionagent observer
+ TBool iConnectionAgentCallbackInitialized;
+ TBool iRegisterFileObserverDone;
+ TBool iRegisterMobilityObserverDone;
+ TBool iRegisterAuthObserverDone;
+ TBool iRegisterCoBrandingObserverDone;
+ TBool iReauthenticationNeeded;
+ MSenCoBrandingObserver* ipCoBrandingObserver;
+ MSenHostletConsumer* ipHostletConsumer;
+ MSenExtendedConsumerInterface* ipExtendedConsumerInterface; // connectionagent observer
+ TAny* ipInterface;
+#ifdef __ENABLE_ALR__
+ MMobilityProtocolResp * iMobiltyObserver;
+ TBool iMobiltyCallBackReceived;
+#endif
+ TBool iCancelSession;
+ TBool iIsInternalSC;
+
+ TThreadId iOwnerThreadId;
+ CSenServiceDispatcher* ipSenServiceDispatcher;
+ CSenUnderTakerWaiter* ipSenUnderTakerWaiter;
+ TInt iVirtualTransactionCounter;
+ TBool iDispatcherEnabled;
+ CSenRegistrationTimer* ipRegistrationTimer;
+ RFile iSharedFileHandle ;
+ };
+
+#ifdef EKA2
+NONSHARABLE_CLASS(CSenAsyncOperation) : public CActive
+#else
+class CSenAsyncOperation : public CActive
+#endif
+ {
+ public: // Constructors and destructor
+ static CSenAsyncOperation* NewL(CSenServiceConnectionImpl* aActive);
+ static CSenAsyncOperation* NewLC(CSenServiceConnectionImpl* aActive);
+ virtual ~CSenAsyncOperation();
+
+ protected: // Functions from base classes
+ // from CActive
+ void RunL();
+ void DoCancel();
+ /* TInt RunError(TInt aError); */
+
+
+ private:
+ /**
+ * By default Symbian 2nd phase constructor is private.
+ */
+ void ConstructL();
+ CSenAsyncOperation(CSenServiceConnectionImpl* iActive);
+
+ public: // Data
+ CSenServiceConnectionImpl* iActive;
+ TInt iErrorNumber;
+ TPtr8 iErrorNumberBuffer;
+ TInt iTxnId;
+ TPtr8 iTxnIdBuffer;
+ TInt iReauthTxnId; // This is used to find connection chunk in the reauthentication loop
+ };
+
+#ifdef EKA2
+NONSHARABLE_CLASS(CSenConnectionStatusObserver) : public CActive
+#else
+class CSenConnectionStatusObserver : public CActive
+#endif
+ {
+ public:
+ static CSenConnectionStatusObserver* NewL(MSenServiceConsumer& aObserver,
+ TInt aConnectionID);
+ static CSenConnectionStatusObserver* NewLC(MSenServiceConsumer& aObserver,
+ TInt aConnectionID);
+ ~CSenConnectionStatusObserver();
+
+ private:
+ CSenConnectionStatusObserver(MSenServiceConsumer& aObserver,
+ TInt aConnectionID);
+ void ConstructL();
+ void RunL();
+ void DoCancel();
+
+ private:
+ RProperty iConnectionStatusProperty;
+ MSenServiceConsumer* iObserver; // not owned
+ TInt iConnectionID;
+ };
+
+
+#ifdef EKA2
+NONSHARABLE_CLASS(CSenFileProgressObserver) : public CActive
+#else
+class CSenFileProgressObserver : public CActive
+#endif
+ {
+ public:
+ static CSenFileProgressObserver* NewL( MSenFilesObserver& aObserver,
+ TInt aConnectionID,
+ TBool aIsDispatcherEnabled,
+ CSenServiceDispatcher* apSenServiceDispatcher,
+ RChunkMap& aChunkMap );
+
+ static CSenFileProgressObserver* NewLC( MSenFilesObserver& aObserver,
+ TInt aConnectionID,
+ TBool aIsDispatcherEnabled,
+ CSenServiceDispatcher* apSenServiceDispatcher,
+ RChunkMap& aChunkMap );
+ ~CSenFileProgressObserver();
+
+ private:
+ CSenFileProgressObserver( MSenFilesObserver& aObserver,
+ TInt aConnectionID,
+ TBool aIsDispatcherEnabled,
+ CSenServiceDispatcher* apSenServiceDispatcher,
+ RChunkMap& aChunkMap );
+ void ConstructL();
+ /*
+ * Method update the consumer about the file progress transfer info
+ */
+ void RunL();
+ void DoCancel();
+ TInt RunError(TInt aError);
+
+ private:
+ RProperty iFileProgressProperty;
+ MSenFilesObserver* iFileProgressObserver; // not owned
+ TInt iConnectionID;
+ TBool iIsDispatcherEnabled;
+ CSenServiceDispatcher* ipSenServiceDispatcher;
+ RChunkMap& iChunkMap;
+ };
+
+#ifdef EKA2
+NONSHARABLE_CLASS(CSenBinaryContainer) : public CBase
+#else
+class CSenBinaryContainer : public CBase
+#endif
+ {
+ public:
+
+
+ enum TDataType
+ {
+ EFile = 0,
+ EChunk = 1,
+ ENumberOfTypes = 2
+ };
+
+ // Constructors and destructor
+ static CSenBinaryContainer* NewL( const TDesC8& aCid, RFile aFile );
+ static CSenBinaryContainer* NewLC( const TDesC8& aCid, RFile aFile );
+
+ static CSenBinaryContainer* NewL( const TDesC8& aCid, RChunk aChunk, TInt aChunkSize, TInt aChunkOffset );
+ static CSenBinaryContainer* NewLC( const TDesC8& aCid, RChunk aChunk, TInt aChunkSize, TInt aChunkOffset );
+
+ TBool IsFile() const; // checks iType (TDataType)
+ TBool IsChunk() const; // checks iType (TDataType)
+ TDataType Type() const;
+
+ TPtrC8 Cid() const;
+ const HBufC8* CidPtr() const;
+ RFile File() const;
+ RChunk Chunk() const;
+ TInt ChunkSize() const;
+ TInt ChunkOffset() const;
+
+ ~CSenBinaryContainer();
+
+ private:
+ void ConstructL( const TDesC8& aCid, RFile aFile );
+ void ConstructL( const TDesC8& aCid, RChunk aChunk, TInt aChunkSize, TInt aChunkOffset );
+
+ CSenBinaryContainer( TDataType aType );
+
+
+ private: // Data
+ // "a temporary fix" for issue 21 => in reality, A MAP IS NEEDED (cid, <handle>) in here (or ipDataContainerArray needs to hold a copy!)
+ TDataType iType;
+ HBufC8* ipCid;
+ RFile iFile;
+ RChunk iChunk;
+ TInt iChunkSize;
+ TInt iChunkOffset;
+ };
+
+
+
+
+#ifdef EKA2
+NONSHARABLE_CLASS(CSenConnectionChunk) : public CSenChunk
+#else
+class CSenConnectionChunk : public CSenChunk
+#endif
+ {
+ friend class CSenServiceConnectionImpl;
+
+ public:
+ // Constructors and destructor
+ static CSenConnectionChunk* NewL(const TDesC& aChunkName, TBool aInternal = EFalse );
+ static CSenConnectionChunk* NewLC(const TDesC& aChunkName, TBool aInternal = EFalse );
+
+ ~CSenConnectionChunk();
+
+ // New methods:
+ RArray<TXmlEngDataContainer>& BinaryDataArrayL(); //codescannerwarnings
+ TBool HasBinaryDataArray();
+ TBool HasSharedFileHandle();
+ void HasSharedFileHandle(TBool aHasSharedFileHandle);
+ void RemoveBinaryDataArrayIfEmpty();
+ TInt AddFileToContainerMap( const TDesC8& aCid, RFile aFile );
+ TInt AddChunkToContainerMap( const TDesC8& aCid, RChunk aChunk, TInt aChunkSize, TInt aChunkOffset );
+ RBinaryMap& ContainerMap();
+ TInt ContainerCount();
+
+#ifndef RD_SEN_ENABLE_USE_OF_WSD_IN_SC_FOR_HW_TARGET
+ // in WINSCW environment, we don't need to use WSD, since there is no limitation for how many chunk handles a single process can have open
+ TInt ServOpenChunkCount();
+#else
+ // use WSD only in hardware builds, since in emulator environment, only a single process can use WSD(!)
+ static TInt ServOpenChunkCount();
+#endif
+ private:
+ void ConstructL(const TDesC& aChunkName);
+
+ CSenConnectionChunk();
+
+ private: // Data
+ RArray<TXmlEngDataContainer>* ipDataContainerArray; // owned
+ TBool iHasSharedFileHandle ;
+ // Proper solution uses the map(!):
+ RBinaryMap iMap;
+#ifndef RD_SEN_ENABLE_USE_OF_WSD_IN_SC_FOR_HW_TARGET
+ TInt iServOpenChunkCount; // WINS env: no need to have static member. To monitor Server side Open chunk count
+#else
+ static TInt iServOpenChunkCount; // ARMv5 env: we need stati member. To monitor Server side Open chunk count
+#endif
+ };
+
+#endif //SEN_SERVICE_CONNECTION_IMPL_H
+
+// End of File