1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:        

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 // INCLUDE FILES

    26 #include <SenXmlUtils.h>

    27 #include <SenServiceConnection.h>

    28 

    29 

    30 #include "idwsfsessionconsumer.h"

    31 #include "idwsfmessage.h"

    32 #include "sendebug.h"

    33 #include "senlogger.h"

    34 

    35 #include <flogger.h>

    36 

    37 CIdWsfSessionConsumer* CIdWsfSessionConsumer::NewL(MSenRemoteServiceConsumer& aServiceConsumer,

    38                                                    RFileLogger& aLogger)

    39     {

    40     CIdWsfSessionConsumer* pSelf =

    41         CIdWsfSessionConsumer::NewLC(aServiceConsumer, aLogger);

    42     CleanupStack::Pop(pSelf);

    43     return pSelf;

    44     }

    45 

    46 CIdWsfSessionConsumer* CIdWsfSessionConsumer::NewLC(MSenRemoteServiceConsumer& aServiceConsumer,

    47                                                     RFileLogger& aLogger)

    48     {

    49     CIdWsfSessionConsumer* pSelf =

    50                         new (ELeave) CIdWsfSessionConsumer(aServiceConsumer, aLogger);

    51     CleanupStack::PushL(pSelf);

    52     pSelf->ConstructL();

    53     return pSelf;

    54     }

    55 

    56 CIdWsfSessionConsumer::~CIdWsfSessionConsumer()

    57     {

    58     delete iSentMessageId;

    59     delete iReceivedMessageId;

    60     iSentMessages.Reset();

    61     }

    62 

    63 CIdWsfSessionConsumer::CIdWsfSessionConsumer(MSenRemoteServiceConsumer& aServiceConsumer,

    64                                              RFileLogger& aLogger)

    65 :   iConsumer(aServiceConsumer),

    66     iLogger(aLogger),

    67     iSentMessageId(NULL),

    68     iReceivedMessageId(NULL),

    69     iSentMessages(ETrue, ETrue)

    70     {

    71     }

    72 

    73 

    74 const TDesC8& CIdWsfSessionConsumer::Id() const

    75     {

    76     return iConsumer.Id();

    77     }

    78 

    79 TInt CIdWsfSessionConsumer::SetSessionL(MSenRemoteServiceSession& aServiceSession)

    80     {

    81     iConsumer.SetSessionL(aServiceSession);

    82     return KErrNone;

    83     }

    84 

    85 TInt CIdWsfSessionConsumer::HandleIdWsfMessageL( CIdWsfMessage* apMessage,

    86                                                  const TInt aTxnId,

    87                                                  MSenProperties* aResponseTransportProperties,

    88                                                  TBool aCompleteMessage )

    89     {

    90     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleIdWsfMessageL");

    91     

    92     TInt retVal(KErrNone);

    93     if ( apMessage )

    94         {

    95         CleanupStack::PushL( apMessage ); // ownership is here

    96     

    97         iSentMessages.RemoveByKey( apMessage->MessageId() );

    98     

    99         HBufC8* pMessageAsString = NULL;

   100         

   101     	//TSW ID: EMKY-6S4CGS & ID:EMKY-6N3AGA

   102     	// Check if aCompleteMessage in ON then get entire envelope or else only body

   103         if ( aCompleteMessage )

   104             {

   105             pMessageAsString = apMessage->AsXmlL();

   106             }

   107         else

   108             {

   109             pMessageAsString = apMessage->BodyAsStringL();

   110             }

   111         CleanupStack::PopAndDestroy( apMessage ); // object serialized to descriptor, de-alloc!

   112     

   113         if( pMessageAsString )

   114             {

   115             retVal = iConsumer.HandleMessageL(pMessageAsString, aTxnId, aResponseTransportProperties);

   116             }

   117         else

   118             {

   119             TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleIdWsfMessageL:");

   120             TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- Fatal(!): pMessageAsString == NULL, calling remote consumer's HandleErrorL with KErrSenNoSoapBody");

   121             retVal = iConsumer.HandleErrorL(NULL, KErrSenNoSoapBody, aTxnId, aResponseTransportProperties);

   122             }

   123         }

   124     else // apMessage == NULL

   125         {

   126         TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleIdWsfMessageL:");

   127         TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- Fatal(!): apMessage == NULL, calling remote consumer's HandleErrorL with KErrSenInternalError");

   128         retVal = iConsumer.HandleErrorL( NULL, KErrSenInternal, aTxnId, aResponseTransportProperties);

   129         TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMinLogLevel  ,_L("CIdWsfSessionConsumer::HandleIdWsfMessageL - HandleErrorL returned: %d. Returning KErrSenInternalError in ANY case."), retVal));

   130         retVal = KErrSenInternal;            

   131         }        

   132     return retVal;

   133     }

   134 

   135 TInt CIdWsfSessionConsumer::HandleMessageL( HBufC8* apMessage,

   136                                             const TInt aTxnId,

   137                                             MSenProperties* aResponseTransportProperties ) 

   138     {

   139     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleMessageL - passing message to consumer");

   140     return iConsumer.HandleMessageL( apMessage, aTxnId, aResponseTransportProperties );

   141     }

   142 

   143 TInt CIdWsfSessionConsumer::HandleErrorL( HBufC8* apError,

   144                                           const TInt aErrorCode,

   145                                           const TInt aTxnId,

   146                                           MSenProperties* aResponseTransportProperties )

   147     {

   148     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleErrorL - passing error to consumer");

   149     return iConsumer.HandleErrorL( apError, aErrorCode, aTxnId, aResponseTransportProperties );

   150     }

   151 

   152 void CIdWsfSessionConsumer::SetStatusL(const TInt status)

   153     {

   154     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::SetStatusL");

   155     iConsumer.SetStatusL(status);

   156     }

   157 

   158 TInt CIdWsfSessionConsumer::MessageForSendingL( const TDesC8& aBody,

   159                                                 const TDesC8& aReceivedMessageId,

   160                                                 CIdWsfMessage*& apMessage )

   161     {

   162     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::MessageForSendingL");

   163     if(aReceivedMessageId.Length()>0)

   164         {

   165         apMessage = CIdWsfMessage::NewL(aReceivedMessageId);

   166         }

   167     else

   168         {

   169         apMessage = CIdWsfMessage::NewL();

   170         }

   171 

   172     apMessage->SetBodyL(aBody);

   173     iSentMessages.Append(apMessage->MessageId().AllocL(), aBody.AllocL());

   174     return KErrNone;

   175     }

   176 

   177 void CIdWsfSessionConsumer::ConstructL()

   178     {

   179     }

   180 

   181 void CIdWsfSessionConsumer::SetSentMessageIdL(const TDesC8& aSentMessageId)

   182     {

   183     HBufC8* pNew = NULL;

   184     if(aSentMessageId.Length()>0)

   185     pNew = aSentMessageId.AllocL();    

   186     delete iSentMessageId;

   187     iSentMessageId = pNew;

   188     }

   189 

   190 TPtrC8 CIdWsfSessionConsumer::SentMessageId()

   191     {

   192     if(iSentMessageId)

   193         {

   194         return *iSentMessageId;

   195         }

   196     else

   197         {

   198         return KNullDesC8();

   199         }

   200     }

   201 

   202 void CIdWsfSessionConsumer::SetReceivedMessageIdL(

   203                                             const TDesC8& aReceivedMessageId)

   204     {

   205     HBufC8* pNew =NULL;

   206     if(aReceivedMessageId.Length()>0)

   207         pNew = aReceivedMessageId.AllocL();

   208     delete iReceivedMessageId;

   209     iReceivedMessageId = pNew;

   210     }

   211 

   212 TPtrC8 CIdWsfSessionConsumer::ReceivedMessageId()

   213     {

   214     if(iReceivedMessageId)

   215         return *iReceivedMessageId;

   216     else

   217         return KNullDesC8();

   218     }

   219 

   220 

   221 

   222 TBool CIdWsfSessionConsumer::Expects(const TDesC8& aRefToMessageID)

   223     {

   224     TInt index = iSentMessages.Find(aRefToMessageID);

   225     if (index != KErrNotFound)

   226         {

   227         return ETrue;

   228         }

   229 

   230     return EFalse;

   231     }

   232 

   233 TDesC8* CIdWsfSessionConsumer::BodyL(const TDesC8& aMessageID) const

   234     {

   235     HBufC8* pBody = NULL;

   236 

   237     TInt index = iSentMessages.Find(aMessageID);

   238     if (index != KErrNotFound)

   239         {

   240         pBody = (HBufC8*)iSentMessages.ValueAt(index);

   241         }

   242 

   243     return pBody;

   244     }

   245 

   246 MSenTransport& CIdWsfSessionConsumer::TransportL()

   247     {

   248     return iConsumer.TransportL();

   249     }

   250 

   251 CSenIdentifier& CIdWsfSessionConsumer::Identifier() const

   252     {

   253     return iConsumer.Identifier();

   254     }

   255 

   256 

   257 // enable file logging (macros)

   258 RFileLogger* CIdWsfSessionConsumer::Log() const

   259     {

   260     return (RFileLogger*) &iLogger;

   261     }

   262 

   263 

   264 TInt CIdWsfSessionConsumer::ChunkByTxnIdL(TInt aTxnId, CSenChunk*& aChunk)

   265     {

   266     return iConsumer.ChunkByTxnIdL(aTxnId, aChunk);

   267     }

   268 

   269 void CIdWsfSessionConsumer::FileProgress(TInt /*aTxnId*/, TBool /*aIncoming*/, TBool /*aIsSoap*/,

   270                 const TDesC8& /*aSoapOrCid*/, TInt /*aProgress*/)

   271     {

   272     }

   273 void CIdWsfSessionConsumer::SetDataTrafficDetails( TSenDataTrafficDetails& /* aDetails*/)  

   274 	{

   275 	}

   276 // End of file

   277 

   278