FCL/sf/mw/websrv: comparison webservices/wsconnection/src/senserviceconnectionimpl.cpp

equal deleted inserted replaced

-:150a13bad6af
+:0802db42e4e9
 #include "SenSoapEnvelope2.h"
 #include "SenParser.h"
 #include "senservicemanagerdefines.h"
 #include "SenBaseAttribute.h"
-#include <xmlengchunkcontainer.h>
+#include <xml/dom/xmlengchunkcontainer.h>
-#include <xmlengfilecontainer.h>
+#include <xml/dom/xmlengfilecontainer.h>
-#include <xmlengserializer.h>
+#include <xml/dom/xmlengserializer.h>
 #include "senconnagentserver.h"
 #include "senxmldebug.h"
 #include "senatomentry.h"
 return pNew;
 }
 void CSenServiceConnectionImpl::ConstructL(MSenServiceDescription& aSD)
 {
+	TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::ConstructL(aSD)");
 CSenElement& sdAsElement = ((CSenXmlServiceDescription&)aSD).AsElement();
 // Check if this is an internal service connection:
 const TDesC8* pInternal = sdAsElement.AttrValue( KSenAttrInternalSC );
 if( pInternal )
 #endif //_SENDEBUG
 */
 #ifndef RD_SEN_SC_PROXY_ENABLED_BY_DEFAULT
 ConnectL();
 // #else // ConnectL occurs on  "proxy" / factory  -level
 #endif
+	TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::ConstructL(aSD) Completed");
 }
 void CSenServiceConnectionImpl::ConnectL()
 {
 }
 }
 void CSenServiceConnectionImpl::SetConsumer( MSenServiceConsumer& aConsumer, MSenExtendedConsumerInterface* apExtConsumer )
 {
+TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::SetConsumer");
 iObserver = &aConsumer;
 ipExtendedConsumerInterface = apExtConsumer;
 }
 void CSenServiceConnectionImpl::Consumer( MSenServiceConsumer*& aConsumer, MSenExtendedConsumerInterface*& apExtConsumer )
 {
+TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::Consumer");
 aConsumer = iObserver;
 apExtConsumer = ipExtendedConsumerInterface;
 }
 TPtrC8 CSenServiceConnectionImpl::InitDescription()
 if(iChunkMap)
 {
 iChunkMap->Reset();
 delete iChunkMap;
+iChunkMap = NULL;
 }
 delete iInBuf;
 delete iOutBuf;
 delete iFragment;
 }
 TPtrC CSenServiceConnectionImpl::SessionID()
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::SessionID()")));
 if(ipSessionId)
 {
 return *ipSessionId;
 }
 else
 }
 TInt CSenServiceConnectionImpl::ResponseFromChunk(CSenChunk& aClientOp,
 HBufC8*& aResponseTo)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::ResponseFromChunk()")));
 TInt leaveCode(KErrNone); // handle OOM case:
 // Read response message, SOAP fault OR error
 TPtrC8 response;
 TInt retVal = aClientOp.DescFromChunk(response); // if handle is closed, this will panic.
 if(retVal==KErrNone)
 if(leaveCode!=KErrNone)
 {
 // OOM occured
 retVal = leaveCode;
 }
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::ResponseFromChunk() Completed")));
 return retVal;
 }
 TInt CSenServiceConnectionImpl::SubmitL(const TDesC8& aRequest,
 HBufC8*& aResponseTo )
 TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::CheckConnection - KErrServerBusy (not enough message slots)")));
 retVal = KErrServerBusy;
 }
 else if (!IsActive())
 {
-SetActive();
+	SetActive();
 iStatus = KRequestPending;
 }
 	TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::CheckConnection Completed")));
 return retVal;
 }
 TInt* pTxnId = new (ELeave) TInt(++iVirtualTransactionCounter);
 CleanupStack::PushL(pTxnId);
 TInt appendRetVal(KErrNone);
 appendRetVal = ChunkMapL().Append( pTxnId, apClientOp );
-TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KNormalLogLevel , _L8("- ChunkMapL().Append(%d, %d) returned: %d"), *pTxnId, apClientOp->Chunk().Handle(), appendRetVal));
+TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("- ChunkMapL().Append(%d, %d) returned: %d"), *pTxnId, apClientOp->Chunk().Handle(), appendRetVal));
 if( appendRetVal == KErrNone )
 {
 TMessage msg;
 msg.iSenConnectionChunk = apClientOp;
 msg.iSenAsyncOperation = pSenAO;
 if(leaveCode)
 {
 TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("MSenServiceConsumer::HandleErrorL leaved: %d"), leaveCode ));
 }
 }
+		TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::InitializeL() Completed")));
 }
 TPtrC CSenServiceConnectionImpl::NextChunkName()
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::NextChunkName()")));
 if(ipChunkName)
 {
 iChunkNameNumber++;
 TPtr chunkname = ipChunkName->Des();
 chunkname.Zero();
 TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L("CSenServiceConnectionImpl::NextChunkName(): %S"), &chunkname));
 return chunkname.Left(KMaxName); // max length of TName
 }
 else
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::NextChunkName() returns KNullDesC()")));
 return KNullDesC();
 }
 }
 void CSenServiceConnectionImpl::RunL()
 {
 DeliverResponseL(aStatus);
 }
 break ;
 }
 }
+TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::HandleMessageFromChildAOL Completed");
 }
 // Helper function, which delivers response to Service Consumer
 void CSenServiceConnectionImpl::DeliverResponseL(const TInt aErrorCode, CSenChunk* apOperation)
 {
 if( statusCode == KErrNone )
 {
 // STANDARD, "OK" RESPONSE
-TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KNormalLogLevel , _L8("- response, (%d bytes):"), response.Length()));
+TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("- response, (%d bytes):"), response.Length()));
 TLSLOG_ALL(KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel ,(response));
 TRAPD( err, iObserver->HandleMessageL( response ); )
 if(err)
 {
 TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("DeliverResponseL: HandleMessageL() leaved: %d"), err));
 if( statusCode == KErrSenSoapFault)
 {
 TInt error = statusCode;
 // SOAP FAULT
-TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KNormalLogLevel , _L8("- SOAP fault (%d bytes):"), response.Length()));
+TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("- SOAP fault (%d bytes):"), response.Length()));
-TLSLOG_ALL(KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel ,(response));
+TLSLOG_ALL(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,(response));
 if ( error == KErrSenSoapFault && !iInitialized ) // China DC
 {
 TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::DeliverResponseL:");
 TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"- Since the SC is NOT ready, pass KErrSenAuthenticationFault to HandleErrorL instead of KErrSenSoapFault");
 {
 iResponse = NULL;
 CleanupStack::PopAndDestroy( pMessage );
 }
 iTransactionIdKnown = EFalse;
+TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::DeliverResponseL Completed");
 }
 void CSenServiceConnectionImpl::DoCancel()
 {
 TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::DoCancel")));
 }
 const TDesC8& CSenServiceConnectionImpl::LocalName() const
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::LocalName()")));
 if(iFragment)
 return iFragment->LocalName();
 else
 return KNullDesC8;
 }
 const TDesC8& CSenServiceConnectionImpl::NsUri() const
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::NsUri()")));
 if(iFragment)
 return iFragment->NsUri();
 else
 return KNullDesC8;
 }
 const TDesC8& CSenServiceConnectionImpl::NsPrefix() const
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::NsPrefix()")));
 if(iFragment)
 return iFragment->NsPrefix();
 else
 return KNullDesC8;
 }
 void CSenServiceConnectionImpl::WriteAsXMLToL(RWriteStream& aWriteStream)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::WriteAsXMLToL()")));
 if(iFragment)
 {
 iFragment->WriteAsXMLToL(aWriteStream);
 }
 }
 HBufC* CSenServiceConnectionImpl::AsXmlUnicodeL()
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::AsXmlUnicodeL()")));
 if(iFragment)
 {
 return iFragment->AsXmlUnicodeL();
 }
 else
 }
 }
 HBufC8* CSenServiceConnectionImpl::AsXmlL()
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::AsXmlL()")));
 if(iFragment)
 {
 return iFragment->AsXmlL();
 }
 else
 return retVal;
 }
 TBool CSenServiceConnectionImpl::ConsistsOfL(MSenFragment& aCandidate)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::ConsistsOfL()")));
 if (iFragment)
 {
 return iFragment->ConsistsOfL(aCandidate);
 }
 else
 return retVal;
 }
 TInt CSenServiceConnectionImpl::TxnId()
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::TxnId()")));
 if( iTransactionIdKnown )
 {
 if( iTxnId>KErrNone )
 {
 if( iDispatcherEnabled )
 return retVal;
 }
 TInt CSenServiceConnectionImpl::CancelTransaction(TInt aTransactionID)
 {
+TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::CancelTransaction");
 TInt retVal(0);
 if ( iDispatcherEnabled ) // DISPATCHER IS ENABLED
 {
 TInt actualTransID = ipSenServiceDispatcher->GetActualTransactionID(&aTransactionID);
 }
 	ipSenServiceDispatcher->RemoveFromQueue(aTransactionID);
 	TRAP(retVal, DeliverResponseL(KErrSenCancelled,NULL));
 	if( retVal != KErrNone)
 		{
+		TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::CancelTransaction returns [%d]" ), retVal ));
 		return retVal;
 		}
 	}
 }
 else // DISPATCHER IS DISABLED
 {
 iConnection.CancelRequest(aTransactionID);
 }
+TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::CancelTransaction returns [%d]" ), KErrNone ));
 return KErrNone;
 }
 TInt CSenServiceConnectionImpl::TransportPropertiesL(HBufC8*& aProperties)
 {
 return retVal;
 }
 RChunkMap& CSenServiceConnectionImpl::ChunkMapL()
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::ChunkMapL()")));
 if(!iChunkMap)
 {
 iChunkMap = new (ELeave) RChunkMap(ETrue, ETrue);
 }
 return *iChunkMap;
 }
 RPointerArray<CSenAsyncOperation>& CSenServiceConnectionImpl::AsyncOpsArrayL() //codescannerwarnings
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::AsyncOpsArrayL()")));
 if(!iAsyncOpsArray)
 {
 iAsyncOpsArray = new (ELeave) RPointerArray<CSenAsyncOperation>;
 }
 return *iAsyncOpsArray;
 TInt CSenServiceConnectionImpl::AssignPropertiesToChunkL(CSenChunk& aChunk,
 CSenSoapEnvelope& aMessage,
 const TDesC8& aProperties)	//codescannerwarnings
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::AssignPropertiesToChunkL()")));
 TInt retVal(KErrNone);
 if ( aMessage.SoapAction2().Length() > 0 )
 {
 CSenTransportProperties* pProps = CSenTransportProperties::NewLC();
 {
 retVal = aChunk.DescToChunk(*pSoapMsg);
 }
 delete pSoapMsg;
 }
+		TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::AssignPropertiesToChunkL returns [%d]" ), retVal ));
 return retVal;
 }
 TInt CSenServiceConnectionImpl::AssignMessageToChunkL( CSenChunk& aChunk,
 MSenMessage& aMessage ) //codescannerwarnings
 CleanupStack::PopAndDestroy(pSerializer);
 CleanupStack::PopAndDestroy(&buffer);
 CleanupStack::PopAndDestroy(pPropsAsXml);
+TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::AssignMessageToChunkL returns [%d]" ), retVal ));
 return retVal;
 }
 // THIS IS THE SECOND, __MUCH IMPROVED__ VARIANT, WHICH SUPPORTS BOTH CHUNK AND FILE ATTACHEMENTS,
 // plus multiple BLOBs PER ONE MESSAGE AND multiple simultaneous transfers
 TInt CSenServiceConnectionImpl::MoveBinaryContainersToServer( CSenConnectionChunk& aOperation, RArray<TXmlEngDataContainer>& aList )
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::MoveBinaryContainersToServer()")));
 TInt retVal(KErrNone);
 TPtrC8 cid8;
 TBuf8<100> cid(KNullDesC8);
 TInt size;
 {
 break;
 }
 			}
 		}
 }
+TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::MoveBinaryContainersToServer returns [%d]" ), retVal ));
 return retVal;
 }
 TInt CSenServiceConnectionImpl::MoveFileChunkHandleToServer(CSenConnectionChunk& aOperation)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::MoveFileChunkHandleToServer()")));
 TInt retVal(KErrNone);
 retVal = iConnection.SendFileHandle(aOperation,iSharedFileHandle);
 return retVal;
 }
 }
 TInt CSenServiceConnectionImpl::SendL( MSenMessage& aMessage )
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::MoveFileChunkHandleToServer(aMessage)")));
 if ( aMessage.IsSafeToCast( MSenMessage::ESoapEnvelope2 ) )
 {
 CSenSoapEnvelope2& message = (CSenSoapEnvelope2&)aMessage;
 return SendL(message);
 }
 }
 TInt CSenServiceConnectionImpl::SubmitL( MSenMessage& aMessage,
 CSenSoapEnvelope2*& aResponseTo )
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::SubmitL(aMessage, aResponseTo)")));
 if ( aMessage.IsSafeToCast( MSenMessage::ESoapEnvelope2) )
 {
 CSenSoapEnvelope2& message = (CSenSoapEnvelope2&)aMessage;
 return SubmitL(message, aResponseTo);
 }
 void CSenServiceConnectionImpl::MigrateToPrefferedCarrierL(TBool &aUserChoice)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::MigrateToPrefferedCarrierL()")));
 if (iMobiltyObserver)
 {
 User::LeaveIfError(iConnection.MigrateToPrefferedCarrierL(aUserChoice));
 }
 	else
 	    {
 User::Leave(KErrNotFound);
 	    }
+	  TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::MigrateToPrefferedCarrierL() Completed")));
 }
 void CSenServiceConnectionImpl::NewCarrierAcceptedL(TBool &aUserChoice)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::NewCarrierAcceptedL()")));
 if (iMobiltyObserver)
 {
 User::LeaveIfError(iConnection.NewCarrierAcceptedL(aUserChoice));
 }
 	else
 	    {
 User::Leave(KErrNotFound);
 	    }
+	  TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::NewCarrierAcceptedL() Completed")));
 }
 #endif
 TInt CSenServiceConnectionImpl::SendProgressToHostlet(TInt aTxnId,
 TBool aIncoming, const TDesC8& aMessage, const TDesC8& aCid,
 TInt aProgress)
 {
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::SendProgressToHostlet()")));
 TBool isSoap = (aMessage != KNullDesC8);
 TPtrC8 ptr;
 if (isSoap)
 {
 ptr.Set(aMessage);
 {
 TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("Fatal(!) -- CSenServiceConnectionImpl::DeliverStatus(): MSenServiceConsumer::SetStatus - leaves with %d"), leaveCode));
 TLSLOG_FORMAT(( iTlsLogStatusChannel, KSenServiceConnectionStatusLogLevel, _L("Fatal(!) -- CSenServiceConnectionImpl::DeliverStatus(): MSenServiceConsumer::SetStatus - leaves with %d"), leaveCode));
 leaveCode = KErrNone;
 }
+TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::DeliverStatus() Completed")));
 }
 TInt CSenServiceConnectionImpl::IdentityProviderL( CSenIdentityProvider*& apIdentityProvider )
 {
 	TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"CSenServiceConnectionImpl::IdentityProviderL Completed");
 return retVal;
 }
 TInt CSenServiceConnectionImpl::SearchIdentityProviderL( CSenIdentityProvider*& apIdentityProvider, const TDesC8& aProviderId )
-		{
+			{
+			TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::SearchIdentityProviderL()")));
 	    TInt retVal(KErrNone);
 	    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkName());
 	    pSenChunk->SetLogger(Log());
 	    retVal = pSenChunk->CreateChunk();
 	                    }
 	                }
 	            }
 	        }
 	    CleanupStack::PopAndDestroy(pSenChunk);
+			TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::SearchIdentityProviderL returns [%d]" ), retVal ));
 	    return retVal;
 		}
 TInt CSenServiceConnectionImpl::RegisterAuthenticationObserver()
 	{
 return retVal;
 }
 TBool CSenServiceConnectionImpl::HasConnectionAgentCallbackInitialized()
 	{
+	TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::HasConnectionAgentCallbackInitialized()")));
 #ifdef __ENABLE_ALR__
 	if((ipAuthProvider || iFilesObserver || iMobiltyObserver || ipCoBrandingObserver) && iConnectionAgentCallbackInitialized)
 #else
 	if((ipAuthProvider || iFilesObserver || ipCoBrandingObserver) && iConnectionAgentCallbackInitialized)
 #endif //__ENABLE_ALR__
 	}
 void CSenServiceConnectionImpl::DataTrafficDetails(TSenDataTrafficDetails& aDetails,
 												   TSenDataTrafficOperations& aOperations)
 	{
+	TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::DataTrafficDetails()")));
 	iConnection.DataTrafficDetails(aDetails, aOperations);
 	}
 TAny* CSenServiceConnectionImpl::InterfaceByUid( TUid aUID )
 return NULL;
 }
 TInt CSenServiceConnectionImpl::PendingTrasanctionsCount()
 	{
+	TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::PendingTrasanctionsCount()")));
 	return iAsyncOpsArray->Count();
 	}
 CSenAsyncOperation* CSenAsyncOperation::NewL(CSenServiceConnectionImpl* aActive)
 {
 iTxnIdBuffer.Set(reinterpret_cast<TUint8*>(&iTxnId),
 sizeof(TInt),
 sizeof(TInt));
-SetActive();
+if(!IsActive())
+	SetActive();
 	iStatus = KRequestPending;
 #ifdef EKA2
 iActive->AsyncOpsArrayL().AppendL(this);	//codescannerwarnings
 #else
 User::LeaveIfError(iActive->AsyncOpsArrayL().Append(this));	//codescannerwarnings
 	// Use secure id of the loading process instead of server process (ws client process secure id)
 	User::LeaveIfError(iConnectionStatusProperty.Attach(secureID, iConnectionID)); // secureid of the process will be category
 CActiveScheduler::Add(this);
 // Initial subscription
 iConnectionStatusProperty.Subscribe(iStatus);
-SetActive();
+if(!IsActive())
+	SetActive();
 	iStatus = KRequestPending;
 }
 CSenConnectionStatusObserver::~CSenConnectionStatusObserver()
 {
 void CSenConnectionStatusObserver::RunL()
 {
 TLSLOG_L( KSenServiceConnectionStatusLogChannelBase+iConnectionID, KSenServiceConnectionStatusLogLevel, "CSenConnectionStatusObserver::RunL" );
 iConnectionStatusProperty.Subscribe(iStatus);
-SetActive();
+if(!IsActive())
+	SetActive();
 	iStatus = KRequestPending;
 TInt propertyValue(KErrNotFound);
 TInt getPropertyCode = iConnectionStatusProperty.Get(propertyValue);
 if ( getPropertyCode == KErrNone)
 	// Use KSenInterfaceUidFilesObserver extended consumer interface UID
 	User::LeaveIfError(iFileProgressProperty.Attach(KSenInterfaceUidFilesObserver,  iConnectionID)); // KSenInterfaceUidFilesObserver UID will be category
 CActiveScheduler::Add(this);
 // Initial subscription
 iFileProgressProperty.Subscribe(iStatus);
-SetActive();
+if(!IsActive())
+	SetActive();
 iStatus = KRequestPending;
 }
 CSenFileProgressObserver::~CSenFileProgressObserver()
 {
 void CSenFileProgressObserver::RunL()
 {
 // Resubscribe before processing new value to prevent missing updates(!):
 	iFileProgressProperty.Subscribe(iStatus);
-SetActive();
+if(!IsActive())
+	SetActive();
 iStatus = KRequestPending;
 TLSLOG_L( KSenServiceConnectionStatusLogChannelBase+iConnectionID, KSenServiceConnectionStatusLogLevel, "CSenFileProgressObserver::RunL" );
 TPckgBuf<TFileOutgoingTransferProgressBase> progress;

changeset 28	0802db42e4e9
parent 1	272b002df977
child 29	5743aa3a72c3