1 /*

     2 * Copyright (c) 2002-2007 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 "senclientcontext.h"

    27 #include "senapplicationcontext.h" 

    28 #include "sensessioncontext.h"

    29 

    30 EXPORT_C CSenClientContext* CSenClientContext::NewL(TInt aClientId, 

    31                                                     CSenApplicationContext& aCtx)

    32     {

    33     CSenClientContext* pNew = CSenClientContext::NewLC(aClientId, aCtx);

    34     CleanupStack::Pop();

    35     return pNew;

    36     }

    37 

    38 EXPORT_C CSenClientContext* CSenClientContext::NewLC(TInt aClientId, 

    39                                                      CSenApplicationContext& aCtx)

    40     {

    41     CSenClientContext* pNew = new (ELeave) CSenClientContext(aClientId, aCtx);

    42     CleanupStack::PushL(pNew);

    43     pNew->BaseConstructL();

    44     return pNew;

    45     }

    46 

    47 EXPORT_C CSenClientContext::CSenClientContext(TInt aClientId, CSenApplicationContext& aCtx)

    48 :   iClientId(aClientId),

    49     iApplicationContext(aCtx),

    50     iSessions(ETrue, ETrue)

    51     {

    52     }

    53 

    54 EXPORT_C CSenClientContext::~CSenClientContext()

    55     {

    56     }

    57        

    58 EXPORT_C void CSenClientContext::BaseConstructL()

    59     {

    60 //    CSenContext::BaseConstructL();

    61     }

    62 

    63 TInt CSenClientContext::ClientId() const

    64     {

    65     return iClientId;

    66     }

    67     

    68 // From MSenClientContext:

    69 /*

    70 SenContext::TContextType CSenClientContext::Type() const

    71     {

    72     return SenContext::EMessageContext;

    73     }

    74        

    75 SenContext::TContextDirection CSenClientContext::Direction() const

    76     {

    77     return CSenContext::Direction();

    78     }

    79        

    80 TInt CSenClientContext::Add(const TDesC8& aKey, const TDesC8& aValue)

    81     {

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

    83     }

    84        

    85 TInt CSenClientContext::Update(const TDesC8& aKey, const TDesC8& aValue)

    86     {

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

    88     }

    89        

    90 const TDesC8* CSenClientContext::GetDesC8L(const TDesC8& aKey)

    91     {

    92     return CSenContext::GetDesC8L( aKey );

    93     }

    94        

    95 TInt CSenClientContext::Add(const TDesC8& aKey, TInt aValue)

    96     {

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

    98     }

    99        

   100 TInt CSenClientContext::Update(const TDesC8& aKey, TInt aValue)

   101     {

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

   103     }

   104        

   105 const TInt* CSenClientContext::GetIntL(const TDesC8& aKey)

   106     {

   107     return CSenContext::GetIntL( aKey );

   108     }

   109        

   110 TInt CSenClientContext::Add(const TDesC8& aKey, CSenElement* aValue)

   111     {

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

   113     }

   114        

   115 TInt CSenClientContext::Update(const TDesC8& aKey, CSenElement* aValue)

   116     {

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

   118     }

   119        

   120 const CSenElement* CSenClientContext::GetSenElementL(const TDesC8& aKey)

   121     {

   122     return CSenContext::GetSenElementL( aKey );

   123     }

   124        

   125 TInt CSenClientContext::Add(const TDesC8& aKey, TAny* aValue)

   126     {

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

   128     }

   129        

   130 TInt CSenClientContext::Update(const TDesC8& aKey, TAny* aValue)

   131     {

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

   133     }

   134        

   135 TAny* CSenClientContext::GetAny(const TDesC8& aKey)

   136     {

   137     return CSenContext::GetAny( aKey );

   138     }

   139        

   140 TInt CSenClientContext::Remove(const TDesC8& aKey) 

   141     {

   142     return CSenContext::Remove(aKey);

   143     }

   144 

   145 TInt CSenClientContext::Count() const

   146     {

   147     return CSenContext::Count();

   148     }

   149 

   150 TPtrC8 CSenClientContext::KeyAtL(TInt aIndex)

   151     {

   152     return CSenContext::KeyAtL(aIndex);

   153     }

   154 

   155 void CSenClientContext::Reset()

   156     {

   157     CSenContext::Reset();

   158     }

   159     

   160 CSenSoapMessage* CSenClientContext::GetCurrentSoapMessage() // DEPRECATED: 

   161     {

   162     CSenSoapMessage* pSoapMessage = NULL;

   163     

   164     TInt index = iItems.Find( KSenCtxKeyCurrentSoapMessage );

   165     if ( index != KErrNotFound )

   166         {

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

   168         pSoapMessage = &(pItem->ToSenSoapMessageL());

   169         }

   170     return pSoapMessage;

   171     }

   172     

   173 TPtrC8 CSenClientContext::GetMessage()

   174     {

   175     TInt index = iItems.Find( KSenCtxKeyCurrentMessageAsDesc );

   176     if ( index != KErrNotFound )

   177         {

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

   179         const TDesC8* desc = pItem->ToDesC8L();

   180         return *desc;

   181         }

   182     return KNullDesC8();

   183     }

   184     

   185 TInt CSenClientContext::Add(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   186     {

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

   188     }

   189     

   190 TInt CSenClientContext::Update(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   191     {

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

   193     }

   194     

   195 const CSenSoapEnvelope* CSenClientContext::GetSenSoapEnvelopeL(const TDesC8& aKey)

   196     {

   197     TInt index = iItems.Find( aKey );

   198     if ( index != KErrNotFound )

   199         {

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

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

   202         return envelope;

   203         }

   204     return NULL;

   205     }

   206     

   207 MSenMessage* CSenClientContext::Message()

   208     {

   209     TInt index = iItems.Find( KSenCtxKeyMessage );

   210     if ( index != KErrNotFound )

   211         {

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

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

   214         }

   215     return NULL;

   216     }

   217     

   218 TInt CSenClientContext::SetMessage(MSenMessage* apMessage, TBool aOwned)

   219     {

   220     TInt leaveCode(KErrNone);

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

   222 

   223     if( leaveCode != KErrNone ) 

   224         {

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

   226         return leaveCode;

   227         }

   228         

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

   230     if( retCode != KErrNone && aOwned )

   231         {

   232         delete pItem; // delete the orphan item

   233         } 

   234     return retCode;

   235     }

   236     

   237     

   238 CSenChunk* CSenClientContext::Chunk()

   239     {

   240     TInt index = iItems.Find( KSenCtxKeyChunk );

   241     if ( index != KErrNotFound )

   242         {

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

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

   245         }

   246     return NULL;

   247     }

   248     

   249 TInt CSenClientContext::SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned)

   250     {

   251     TInt leaveCode(KErrNone);

   252     

   253     CSenContextItem* pItem = NULL;

   254     if( aOwned )

   255         {

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

   257         }

   258     else // chunk is not to be owned

   259         {

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

   261         }

   262 

   263     if( leaveCode != KErrNone ) 

   264         {

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

   266         return leaveCode;

   267         }

   268         

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

   270     if( retCode != KErrNone && aOwned )

   271         {

   272         delete pItem; // delete the orphan item

   273         } 

   274     return retCode;

   275     }

   276     

   277 

   278 TInt CSenClientContext::SetProperties(MSenProperties* apProperties, TBool aOwned)

   279     {

   280     if( !apProperties )

   281         {

   282         return KErrArgument;

   283         }

   284         

   285     TInt retCode(KErrNone);

   286     if ( aOwned )

   287         {

   288         delete ipOwnedTp;

   289         ipOwnedTp = NULL;

   290         ipOwnedTp = apProperties;

   291         }

   292     else

   293         {

   294         

   295         CSenContextItem* pItem = NULL;

   296         TInt leaveCode(KErrNone);

   297 //        if( aOwned )

   298 //            {

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

   300 //            }

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

   302 //            {

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

   304 //            }

   305 

   306         if( leaveCode != KErrNone ) 

   307             {

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

   309             return leaveCode;

   310             }

   311             

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

   313         if( retCode != KErrNone && aOwned )

   314             {

   315             delete pItem; // delete the orphan item

   316             } 

   317         }

   318     return retCode;

   319     }

   320 

   321 

   322 MSenProperties* CSenClientContext::Properties()

   323     {

   324     if( ipOwnedTp )

   325         {

   326         return ipOwnedTp;

   327         }

   328     else

   329         {

   330         TInt index = iItems.Find( KSenCtxKeyMessageProperties );

   331         if ( index != KErrNotFound )

   332             {

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

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

   335                 {

   336                 MSenProperties* pProperties = (MSenProperties*)pItem;

   337                 return pProperties;

   338                 }

   339             }

   340         return NULL;

   341         }

   342     }

   343 

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

   345 TInt CSenClientContext::Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   346     {

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

   348         {

   349         return KErrAlreadyExists;

   350         }

   351 

   352     TInt leaveCode(KErrNone);

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

   354     if( leaveCode != KErrNone ) 

   355         {

   356         return leaveCode;

   357         }

   358 

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

   360     if( retCode != KErrNone )

   361         {

   362         delete pItem;

   363         }

   364     return retCode;

   365     }

   366     

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

   368 TInt CSenClientContext::Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   369     {

   370     TInt leaveCode(KErrNone);

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

   372     if( leaveCode != KErrNone ) 

   373         {

   374         return leaveCode;

   375         }

   376 

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

   378     if( retCode != KErrNone && aOwned )

   379         {

   380         delete pItem;

   381         }

   382     return retCode;    

   383     }

   384     

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

   386 MSenMessage* CSenClientContext::GetMessage(const TDesC8& aKey)

   387     {

   388     TInt index = iItems.Find(aKey);

   389     if ( index != KErrNotFound )

   390         {

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

   392         if(pItem)

   393             {

   394             return &pItem->ToSenMessageL();

   395             }

   396         }

   397     return NULL;    

   398     }

   399  

   400 // private helper method(s):

   401 CSenContextItem* CSenClientContext::MessageToItem(MSenMessage* apMessage, TBool aOwned, TInt& aError)

   402     {

   403     aError = KErrNone;

   404     CSenContextItem* pItem = NULL;

   405     if( aOwned )

   406         {

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

   408             {

   409             CSenMessageBase* msgBase = (CSenMessageBase*) apMessage;

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

   411             }

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

   413             {

   414             CSenSoapEnvelope2* msgSoap2 = (CSenSoapEnvelope2*) apMessage;

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

   416             }

   417         else 

   418             {

   419             aError = KErrNotSupported;

   420             return NULL;

   421             }

   422         }

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

   424         {

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

   426         }

   427     return pItem;        

   428     } 

   429     

   430 TInt CSenClientContext::SetDirection( SenContext::TContextDirection aDirection )

   431     {

   432     CSenContext::SetDirection( aDirection );

   433     return KErrNone;

   434     }

   435 

   436 const CSenXmlReader* CSenClientContext::GetParser()

   437     {

   438     return CSenContext::GetParser();

   439     }

   440 */       

   441 // End of file

   442