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 // INCLUDE FILES

    26 #include "senwsdescription.h"

    27 #include "sentransportcontext.h"

    28 #include "msencoreservicemanager.h"

    29 #include "senservicesession.h"

    30 #include "sencontextitem.h"

    31 

    32 EXPORT_C CSenTransportContext::CSenTransportContext()

    33 : CSenContext(SenContext::EBoth)

    34     {

    35     }

    36 

    37 EXPORT_C CSenTransportContext::~CSenTransportContext()

    38     {

    39     }

    40 

    41 

    42 EXPORT_C CSenTransportContext* CSenTransportContext::NewL(MSenCoreServiceManager& aCore,

    43                                                                  CSenWSDescription& aSessionInitializer)

    44     {

    45     CSenTransportContext* pNew = CSenTransportContext::NewLC(aCore, aSessionInitializer);

    46     CleanupStack::Pop();

    47     return pNew;

    48     }

    49 

    50 EXPORT_C CSenTransportContext* CSenTransportContext::NewLC(MSenCoreServiceManager& aCore,

    51                                                            CSenWSDescription& aSessionInitializer)

    52     {

    53 //    CSenXmlReader* reader = aCore.XMLReader();

    54 //    if(!reader) User::Leave(KErrArgument); 

    55     CSenTransportContext* pNew = new (ELeave) CSenTransportContext();

    56     CleanupStack::PushL(pNew);

    57     pNew->BaseConstructL(aCore, aSessionInitializer, NULL);

    58     return pNew;

    59     }

    60 

    61 EXPORT_C CSenTransportContext* CSenTransportContext::NewL(MSenCoreServiceManager& aCore,

    62                                                                  CSenWSDescription& aSessionInitializer,

    63                                                                  CSenServiceSession& aInvoker)

    64     {

    65     CSenTransportContext* pNew = CSenTransportContext::NewLC(aCore, aSessionInitializer, aInvoker);

    66     CleanupStack::Pop();

    67     return pNew;

    68     }

    69 

    70 EXPORT_C CSenTransportContext* CSenTransportContext::NewLC(MSenCoreServiceManager& aCore,

    71                                                            CSenWSDescription& aSessionInitializer,

    72                                                            CSenServiceSession& aInvoker)

    73     {

    74     CSenTransportContext* pNew = new (ELeave) CSenTransportContext();

    75     CleanupStack::PushL(pNew);

    76     pNew->BaseConstructL(aCore, aSessionInitializer, &aInvoker);

    77     return pNew;

    78     }

    79 

    80 EXPORT_C void CSenTransportContext::BaseConstructL(MSenCoreServiceManager& aCore,

    81                                                    CSenWSDescription& aSessionInitializer,

    82                                                    CSenServiceSession* apInvoker)

    83     {

    84     CSenContextItem* pCore = CSenContextItem::NewLC(aCore);

    85     User::LeaveIfError( iItems.Append( &KSenCtxKeyCoreServiceManager(), pCore ) );

    86     CleanupStack::Pop(pCore);

    87 

    88     CSenContextItem* pInit = CSenContextItem::NewLC(aSessionInitializer);

    89     User::LeaveIfError( iItems.Append( &KSenCtxKeySessionInitializer(), pInit ) );

    90     CleanupStack::Pop(pInit);

    91 

    92     if(apInvoker)

    93         {

    94         CSenContextItem* pSess = CSenContextItem::NewLC(*apInvoker);

    95         User::LeaveIfError( iItems.Append(&KSenCtxKeyServiceSession(), pSess ) );

    96         CleanupStack::Pop(pSess);

    97         }

    98     }

    99 

   100 // From MSenTransportContext:

   101 //TInt CSenTransportContext::AddCore(MSenCoreServiceManager& aValue)

   102 //    {

   103 //    }

   104 

   105 MSenCoreServiceManager& CSenTransportContext::GetCoreL()

   106     {

   107     TInt index = iItems.Find( KSenCtxKeyCoreServiceManager );

   108     User::LeaveIfError( index );

   109 

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

   111     if ( pItem == NULL ) 

   112         {

   113         User::Leave( KErrNotFound );

   114         }

   115 

   116     return pItem->ToSenCoreL();

   117 

   118 

   119 

   120     /*

   121     TInt leaveCode(KErrNone);

   122     MSenCoreServiceManager* pCore = NULL;

   123     TRAP( leaveCode, pCore = pItem->ToSenCoreL(); )

   124     if( leaveCode == KErrNone ) 

   125         {

   126         return pCore;

   127         }

   128     */

   129     }

   130 

   131 // TInt CSenTransportContext::AddSession(CSenServiceSession* aValue) { };

   132 // TInt CSenTransportContext::UpdateSession(CSenServiceSession* aValue) { };

   133 

   134 

   135 //CSenServiceSession& CSenTransportContext::GetSessionL()

   136 const CSenServiceSession* CSenTransportContext::GetSession()

   137     {

   138     CSenServiceSession* pSession = NULL;

   139     TInt index = iItems.Find( KSenCtxKeyServiceSession );

   140     if(index != KErrNotFound) 

   141         {

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

   143         if ( pItem ) 

   144             {

   145             TInt leaveCode(KErrNone);

   146             TRAP( leaveCode, pSession = &(pItem->ToSenServiceSessionL()); )

   147             if ( leaveCode != KErrNone )

   148                 {

   149                 pSession = NULL;

   150                 }

   151             }

   152         }

   153     return pSession;

   154     }

   155 

   156 //TInt CSenTransportContext::AddInitializer(CSenWSDescription* aValue) { };

   157 

   158 //  TInt CSenTransportContext::UpdateInitializer(CSenWSDescription* aValue);

   159 

   160 //const CSenWSDescription* CSenTransportContext::GetInitializer()

   161 CSenWSDescription& CSenTransportContext::GetInitializerL()

   162      {

   163     TInt index = iItems.Find( KSenCtxKeySessionInitializer );

   164     User::LeaveIfError( index );

   165 

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

   167     if ( pItem == NULL ) 

   168         {

   169         User::Leave( KErrNotFound );

   170         }

   171 

   172     return pItem->ToSenServiceDescriptionL();

   173     }

   174 

   175 // TInt CSenTransportContext::AddServiceDescription(const TDesC8& aKey, CSenWSDescription* aValue);

   176 // TInt CSenTransportContext::UpdateServiceDescription(const TDesC8& aKey, CSenWSDescription* aValue);

   177 // const CSenWSDescription* CSenTransportContext::GetServiceDescriptionL(const TDesC8& aKey);

   178 // TInt CSenTransportContext::Add(const TDesC8& aKey, MSenRemoteServiceSession& aValue); // protected context

   179 // TInt CSenTransportContext::Update(const TDesC8& aKey, MSenRemoteServiceSession& aValue);

   180 // const MSenRemoteServiceSession* CSenTransportContext::GetSenRemoteServiceSessionL(const TDesC8& aKey);

   181 

   182 

   183  // From MSenContext:

   184 SenContext::TContextType CSenTransportContext::Type() const

   185     {

   186     return SenContext::ETransportContext;

   187     }

   188        

   189 SenContext::TContextDirection CSenTransportContext::Direction() const

   190     {

   191     return CSenContext::Direction();

   192     }

   193        

   194 TInt CSenTransportContext::Add(const TDesC8& aKey, const TDesC8& aValue)

   195     {

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

   197     }

   198        

   199 TInt CSenTransportContext::Update(const TDesC8& aKey, const TDesC8& aValue)

   200     {

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

   202     }

   203        

   204 const TDesC8* CSenTransportContext::GetDesC8L(const TDesC8& aKey)

   205     {

   206     return CSenContext::GetDesC8L(aKey);

   207     }

   208        

   209 TInt CSenTransportContext::Add(const TDesC8& aKey, TInt aValue)

   210     {

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

   212     }

   213        

   214 TInt CSenTransportContext::Update(const TDesC8& aKey, TInt aValue)

   215     {

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

   217     }

   218        

   219 const TInt* CSenTransportContext::GetIntL(const TDesC8& aKey)

   220     {

   221     return CSenContext::GetIntL(aKey);

   222     }

   223        

   224 TInt CSenTransportContext::Add(const TDesC8& aKey, CSenElement* aValue)

   225     {

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

   227     }

   228        

   229 TInt CSenTransportContext::Update(const TDesC8& aKey, CSenElement* aValue)

   230     {

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

   232     }

   233        

   234 const CSenElement* CSenTransportContext::GetSenElementL(const TDesC8& aKey)

   235     {

   236     return CSenContext::GetSenElementL(aKey);

   237     }

   238        

   239 TInt CSenTransportContext::Add(const TDesC8& aKey, TAny* aValue)

   240     {

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

   242     }

   243        

   244 TInt CSenTransportContext::Update(const TDesC8& aKey, TAny* aValue)

   245     {

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

   247     }

   248        

   249 TAny* CSenTransportContext::GetAnyL(const TDesC8& aKey)	//codescannerwarnings

   250     {

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

   252     }

   253 

   254 TInt CSenTransportContext::Remove(const TDesC8& aKey) 

   255     {

   256     return CSenContext::Remove(aKey);

   257     }

   258 

   259 TInt CSenTransportContext::Count() const

   260     {

   261     return CSenContext::Count();

   262     }

   263 

   264 TPtrC8 CSenTransportContext::KeyAtL(TInt aIndex)

   265     {

   266     return CSenContext::KeyAtL(aIndex);

   267     }

   268 

   269 void CSenTransportContext::Reset()

   270     {

   271     CSenContext::Reset();

   272     }

   273 

   274 

   275 TInt CSenTransportContext::SetDirection( SenContext::TContextDirection aDirection )

   276     {

   277     return CSenContext::SetDirection( aDirection );

   278     }

   279     

   280 const CSenXmlReader* CSenTransportContext::GetParser()

   281     {

   282     CSenXmlReader* reader = NULL;

   283     MSenCoreServiceManager* core = NULL;

   284     TInt leaveCode(KErrNone);

   285     TRAP( leaveCode, core = &GetCoreL(); )

   286     if( leaveCode == KErrNone && core)

   287         {

   288         TRAP( leaveCode, reader = core->XMLReader(); )

   289         if( leaveCode == KErrNone && reader )

   290             {

   291             return reader;

   292             }

   293         

   294         }

   295     return NULL;

   296     }

   297 

   298 

   299 

   300 // End of File