1 /*

     2 * Copyright (c) 2002-2006 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 

    26 

    27 

    28 // INCLUDE FILES

    29 #include "senmessagecontext.h" 

    30 #include "sencontextitem.h"

    31 #include "SenElement.h"

    32 

    33 #include "sencontextitem.h"

    34 #include "SenXmlReader.h"

    35 #include "msenremoteserviceconsumer.h"

    36 

    37 #include "MSenMessage.h"

    38 #include "senmessagebase.h"

    39 #include "SenSoapEnvelope2.h"

    40 #include "senatomentry.h"

    41 #include "SenSoapMessage2.h"

    42 

    43 #include "MSenProperties.h"

    44 

    45 #include "SenXmlReader.h"

    46 

    47 #include "senlayeredtransportproperties.h"

    48 #include <SenTransportProperties.h>

    49 

    50 

    51 EXPORT_C CSenMessageContext* CSenMessageContext::NewL(SenContext::TContextDirection aDirection, 

    52                                                       MSenProperties* apOwnedTp)

    53     {

    54     CSenMessageContext* pNew = CSenMessageContext::NewLC(aDirection, apOwnedTp);

    55     CleanupStack::Pop();

    56     return pNew;

    57     }

    58 

    59 EXPORT_C CSenMessageContext* CSenMessageContext::NewLC(SenContext::TContextDirection aDirection,

    60                                                        MSenProperties* apOwnedTp)

    61     {

    62     CSenMessageContext* pNew = new (ELeave) CSenMessageContext(aDirection, apOwnedTp);

    63     CleanupStack::PushL(pNew);

    64     pNew->BaseConstructL();

    65     return pNew;

    66     }

    67 

    68 EXPORT_C CSenMessageContext::CSenMessageContext(SenContext::TContextDirection aDirection,

    69                                                 MSenProperties* apOwnedTp)

    70 :  CSenContext( aDirection),

    71    ipOwnedTp ( apOwnedTp )

    72     {

    73     }

    74 

    75 EXPORT_C CSenMessageContext::~CSenMessageContext()

    76     {

    77     if( ipOwnedTp )

    78         {

    79         if( ipOwnedTp->IsSafeToCast(MSenProperties::ESenXmlProperties) )

    80             {

    81             CSenXmlProperties* p = (CSenXmlProperties*)ipOwnedTp;

    82             delete p;

    83             }

    84         else if( ipOwnedTp->IsSafeToCast(MSenProperties::ESenLayeredXmlProperties) )

    85             {

    86             CSenLayeredXmlProperties* lp = (CSenLayeredXmlProperties*)ipOwnedTp;

    87             delete lp;

    88             }

    89             ipOwnedTp = NULL;

    90         }

    91     }

    92        

    93 EXPORT_C void CSenMessageContext::BaseConstructL()

    94     {

    95     CSenContext::BaseConstructL();

    96     }

    97 

    98 // From MSenMessageContext:

    99 SenContext::TContextType CSenMessageContext::Type() const

   100     {

   101     return SenContext::EMessageContext;

   102     }

   103        

   104 SenContext::TContextDirection CSenMessageContext::Direction() const

   105     {

   106     return CSenContext::Direction();

   107     }

   108        

   109 TInt CSenMessageContext::Add(const TDesC8& aKey, const TDesC8& aValue)

   110     {

   111     return CSenContext::Add( aKey, aValue );

   112     }

   113        

   114 TInt CSenMessageContext::Update(const TDesC8& aKey, const TDesC8& aValue)

   115     {

   116     return CSenContext::Update( aKey, aValue );

   117     }

   118        

   119 const TDesC8* CSenMessageContext::GetDesC8L(const TDesC8& aKey)

   120     {

   121     return CSenContext::GetDesC8L( aKey );

   122     }

   123        

   124 TInt CSenMessageContext::Add(const TDesC8& aKey, TInt aValue)

   125     {

   126     return CSenContext::Add( aKey, aValue );

   127     }

   128        

   129 TInt CSenMessageContext::Update(const TDesC8& aKey, TInt aValue)

   130     {

   131     return CSenContext::Update( aKey, aValue );

   132     }

   133        

   134 const TInt* CSenMessageContext::GetIntL(const TDesC8& aKey)

   135     {

   136     return CSenContext::GetIntL( aKey );

   137     }

   138        

   139 TInt CSenMessageContext::Add(const TDesC8& aKey, CSenElement* aValue)

   140     {

   141     return CSenContext::Add( aKey, aValue );

   142     }

   143        

   144 TInt CSenMessageContext::Update(const TDesC8& aKey, CSenElement* aValue)

   145     {

   146     return CSenContext::Update( aKey, aValue );

   147     }

   148        

   149 const CSenElement* CSenMessageContext::GetSenElementL(const TDesC8& aKey)

   150     {

   151     return CSenContext::GetSenElementL( aKey );

   152     }

   153        

   154 TInt CSenMessageContext::Add(const TDesC8& aKey, TAny* aValue)

   155     {

   156     return CSenContext::Add( aKey, aValue );

   157     }

   158        

   159 TInt CSenMessageContext::Update(const TDesC8& aKey, TAny* aValue)

   160     {

   161     return CSenContext::Update( aKey, aValue );

   162     }

   163        

   164 TAny* CSenMessageContext::GetAnyL(const TDesC8& aKey)		//codescannerwarnings

   165     {

   166     return CSenContext::GetAnyL( aKey );		//codescannerwarnings

   167     }

   168        

   169 TInt CSenMessageContext::Remove(const TDesC8& aKey) 

   170     {

   171     return CSenContext::Remove(aKey);

   172     }

   173 

   174 TInt CSenMessageContext::Count() const

   175     {

   176     return CSenContext::Count();

   177     }

   178 

   179 TPtrC8 CSenMessageContext::KeyAtL(TInt aIndex)

   180     {

   181     return CSenContext::KeyAtL(aIndex);

   182     }

   183 

   184 void CSenMessageContext::Reset()

   185     {

   186     CSenContext::Reset();

   187     }

   188     

   189 CSenSoapMessage* CSenMessageContext::GetCurrentSoapMessage() // DEPRECATED: 

   190     {

   191     CSenSoapMessage* pSoapMessage = NULL;

   192     

   193     TInt index = iItems.Find( KSenCtxKeyCurrentSoapMessage );

   194     if ( index != KErrNotFound )

   195         {

   196         const CSenContextItem* pItem = iItems.ValueAt(index);

   197         TRAPD( err, pSoapMessage = &(pItem->ToSenSoapMessageL()); )

   198         if( err )

   199             {

   200             pSoapMessage = NULL;   

   201             }

   202         }

   203     return pSoapMessage;

   204     }

   205     

   206 TPtrC8 CSenMessageContext::GetMessageL()

   207     {

   208     TPtrC8 retVal( KNullDesC8 );        

   209     TInt index = iItems.Find( KSenCtxKeyCurrentMessageAsDesc );

   210     if ( index != KErrNotFound )

   211         {

   212         const CSenContextItem* pItem = iItems.ValueAt(index);

   213         TInt err( KErrNone );

   214         //TRAP( err, retVal.Set ( *(pItem->ToDesC8L()) );

   215         TRAP

   216             ( 

   217             err, 

   218             const TDesC8* pDesc = pItem->ToDesC8L(); 

   219             if( pDesc )

   220                 {

   221                 retVal.Set( *pDesc );

   222                 }

   223             )

   224         err = 0; // ignored

   225         }

   226     return retVal;

   227     }

   228     

   229 TInt CSenMessageContext::Add(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   230     {

   231     return CSenContext::Add( aKey, aValue );    

   232     }

   233     

   234 TInt CSenMessageContext::Update(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   235     {

   236     return CSenContext::Update( aKey, aValue );

   237     }

   238     

   239 const CSenSoapEnvelope* CSenMessageContext::GetSenSoapEnvelopeL(const TDesC8& aKey)

   240     {

   241     TInt index = iItems.Find( aKey );

   242     if ( index != KErrNotFound )

   243         {

   244         const CSenContextItem* pItem = iItems.ValueAt(index);

   245         const CSenSoapEnvelope* envelope = ((CSenSoapEnvelope*)&(pItem->ToSenSoapMessageL()));

   246         return envelope;

   247         }

   248     return NULL;

   249     }

   250     

   251 MSenMessage* CSenMessageContext::MessageL()		//codescannerwarnigs

   252     {

   253     TInt index = iItems.Find( KSenCtxKeyMessage );

   254     if ( index != KErrNotFound )

   255         {

   256         const CSenContextItem* pItem = iItems.ValueAt(index);

   257         return ((MSenMessage*)&(pItem->ToSenMessageL()));

   258         }

   259     return NULL;

   260     }

   261     

   262 TInt CSenMessageContext::SetMessage(MSenMessage* apMessage, TBool aOwned)

   263     {

   264     TInt leaveCode(KErrNone);

   265     CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );

   266 

   267     if( leaveCode != KErrNone ) 

   268         {

   269         delete pItem; // should ALWAYS be NULL(!)

   270         return leaveCode;

   271         }

   272         

   273     TInt retCode(iItems.UpdateValue(&KSenCtxKeyMessage(), pItem));

   274     if( retCode != KErrNone && aOwned )

   275         {

   276         delete pItem; // delete the orphan item

   277         } 

   278     return retCode;

   279     }

   280     

   281     

   282 CSenChunk* CSenMessageContext::ChunkL()	//codescannerwarnings

   283     {

   284     TInt index = iItems.Find( KSenCtxKeyChunk );

   285     if ( index != KErrNotFound )

   286         {

   287         const CSenContextItem* pItem = iItems.ValueAt(index);

   288         return ((CSenChunk*)&(pItem->ToSenChunkL()));

   289         }

   290     return NULL;

   291     }

   292     

   293 TInt CSenMessageContext::SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned)

   294     {

   295     TInt leaveCode(KErrNone);

   296     

   297     CSenContextItem* pItem = NULL;

   298     if( aOwned )

   299         {

   300         TRAP( leaveCode, pItem = CSenContextItem::NewL(apMsgAsChunk); )

   301         }

   302     else // chunk is not to be owned

   303         {

   304         TRAP( leaveCode, pItem = CSenContextItem::NewL(*apMsgAsChunk); )

   305         }

   306 

   307     if( leaveCode != KErrNone ) 

   308         {

   309         delete pItem; // should ALWAYS be NULL(!)

   310         return leaveCode;

   311         }

   312         

   313     TInt retCode(iItems.UpdateValue(&KSenCtxKeyChunk(), pItem));

   314     if( retCode != KErrNone && aOwned )

   315         {

   316         delete pItem; // delete the orphan item

   317         } 

   318     return retCode;

   319     }

   320     

   321 

   322 TInt CSenMessageContext::SetProperties(MSenProperties* apProperties, TBool aOwned)

   323     {

   324     if( !apProperties )

   325         {

   326         return KErrArgument;

   327         }

   328         

   329     TInt retCode(KErrNone);

   330     if ( aOwned )

   331         {

   332         delete ipOwnedTp;

   333         ipOwnedTp = NULL;

   334         ipOwnedTp = apProperties;

   335         }

   336     else

   337         {

   338         

   339         CSenContextItem* pItem = NULL;

   340         TInt leaveCode(KErrNone);

   341 //        if( aOwned )

   342 //            {

   343 //            TRAP( leaveCode, pItem = CSenContextItem::NewL(apProperties); )

   344 //            }

   345 //        else // chunk is not to be owned

   346 //            {

   347             TRAP( leaveCode, pItem = CSenContextItem::NewL(*apProperties); )

   348 //            }

   349 

   350         if( leaveCode != KErrNone ) 

   351             {

   352             delete pItem; // should ALWAYS be NULL(!)

   353             return leaveCode;

   354             }

   355             

   356         retCode = iItems.UpdateValue(&KSenCtxKeyChunk(), pItem);

   357         if( retCode != KErrNone && aOwned )

   358             {

   359             delete pItem; // delete the orphan item

   360             } 

   361         }

   362     return retCode;

   363     }

   364 

   365 

   366 MSenProperties* CSenMessageContext::Properties()

   367     {

   368     if( ipOwnedTp )

   369         {

   370         return ipOwnedTp;

   371         }

   372     else

   373         {

   374         TInt index = iItems.Find( KSenCtxKeyMessageProperties );

   375         if ( index != KErrNotFound )

   376             {

   377             const CSenContextItem* pItem = iItems.ValueAt(index);

   378             if( pItem->Type() == MSenContextItem::EMSenProperties )

   379                 {

   380                 MSenProperties* pProperties = (MSenProperties*)pItem;

   381                 return pProperties;

   382                 }

   383             }

   384         return NULL;

   385         }

   386     }

   387 

   388 // Method for adding an "intermediate" message behind certain key; used normally to conduct final "service message"

   389 TInt CSenMessageContext::Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   390     {

   391     if( iItems.Count() > 0 && iItems.Find(aKey) != KErrNotFound )

   392         {

   393         return KErrAlreadyExists;

   394         }

   395 

   396     TInt leaveCode(KErrNone);

   397     CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );

   398     if( leaveCode != KErrNone ) 

   399         {

   400         return leaveCode;

   401         }

   402 

   403     TInt retCode(iItems.Append(&aKey, pItem));

   404     if( retCode != KErrNone )

   405         {

   406         delete pItem;

   407         }

   408     return retCode;

   409     }

   410     

   411 // Method for updating some "intermediate" message behind certain key; used normally to conduct final "service message"    

   412 TInt CSenMessageContext::Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   413     {

   414     TInt leaveCode(KErrNone);

   415     CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );

   416     if( leaveCode != KErrNone ) 

   417         {

   418         return leaveCode;

   419         }

   420 

   421     TInt retCode(iItems.UpdateValue(&aKey, pItem));

   422     if( retCode != KErrNone && aOwned )

   423         {

   424         delete pItem;

   425         }

   426     return retCode;    

   427     }

   428     

   429 // Method for getting "intermediate" message behind certain key; used normally to conduct final "service message"    

   430 MSenMessage* CSenMessageContext::GetMessageL(const TDesC8& aKey)	//codescannerwarnings

   431     {

   432     TInt index = iItems.Find(aKey);

   433     if ( index != KErrNotFound )

   434         {

   435         const CSenContextItem* pItem = iItems.ValueAt(index);

   436         if(pItem)

   437             {

   438             return &pItem->ToSenMessageL();

   439             }

   440         }

   441     return NULL;    

   442     }

   443  

   444 // private helper method(s):

   445 CSenContextItem* CSenMessageContext::MessageToItem(MSenMessage* apMessage, TBool aOwned, TInt& aError)

   446     {

   447     aError = KErrNone;

   448     CSenContextItem* pItem = NULL;

   449     if( aOwned )

   450         {

   451         if( apMessage->IsSafeToCast( MSenMessage::EMessageBase ) )

   452             {

   453             CSenMessageBase* msgBase = (CSenMessageBase*) apMessage;

   454             TRAP( aError, pItem = CSenContextItem::NewL( msgBase ); )

   455             }

   456         else if ( apMessage->IsSafeToCast( MSenMessage::ESoapEnvelope2 ) )

   457             {

   458             CSenSoapEnvelope2* msgSoap2 = (CSenSoapEnvelope2*) apMessage;

   459             TRAP( aError,  pItem = CSenContextItem::NewL( msgSoap2 ); )

   460             }

   461         else if ( apMessage->IsSafeToCast( MSenMessage::EAtomMessage ) )

   462             {

   463             CSenAtomEntry* msgAtomEntry = (CSenAtomEntry*) apMessage;

   464             TRAP( aError,  pItem = CSenContextItem::NewL( msgAtomEntry ); )

   465             }

   466         else 

   467             {

   468             aError = KErrNotSupported;

   469             return NULL;

   470             }

   471         }

   472     else // provided message is *not to be owned*

   473         {

   474         TRAP( aError, pItem = CSenContextItem::NewL(*apMessage); )

   475         }

   476     return pItem;        

   477     } 

   478     

   479 TInt CSenMessageContext::SetDirection( SenContext::TContextDirection aDirection )

   480     {

   481     CSenContext::SetDirection( aDirection );

   482     return KErrNone;

   483     }

   484 

   485 const CSenXmlReader* CSenMessageContext::GetParser()

   486     {

   487     return CSenContext::GetParser();

   488     }

   489        

   490 // End of file

   491