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 "e32cmn.h"

    27 

    28 #include "senservercontext.h" 

    29 #include "sencoreservicemanager.h" // Core\inc

    30 #include "senapplicationcontext.h"

    31 #include <SenServiceConnection.h> // KErrSenInternal

    32 

    33 EXPORT_C CSenServerContext* CSenServerContext::NewL(MSenCoreServiceManager& aCore)

    34     {

    35     CSenServerContext* pNew = CSenServerContext::NewLC(aCore);

    36     CleanupStack::Pop();

    37     return pNew;

    38     }

    39 

    40 EXPORT_C CSenServerContext* CSenServerContext::NewLC(MSenCoreServiceManager& aCore)

    41     {

    42     CSenServerContext* pNew = new (ELeave) CSenServerContext(aCore);

    43     CleanupStack::PushL(pNew);

    44     pNew->BaseConstructL();

    45     return pNew;

    46     }

    47 

    48 EXPORT_C CSenServerContext::CSenServerContext(MSenCoreServiceManager& aCore)

    49 : iApplications(ETrue, ETrue),

    50   iCore(aCore)

    51     {

    52     }

    53 

    54 EXPORT_C CSenServerContext::~CSenServerContext()

    55     {

    56     iApplications.Reset(); // de-alloc secure-id's and application contexts

    57     }

    58        

    59 EXPORT_C void CSenServerContext::BaseConstructL()

    60     {

    61 //    CSenContext::BaseConstructL();

    62     }

    63     

    64 MSenCoreServiceManager& CSenServerContext::Core()

    65     {

    66     return iCore;

    67     }

    68 

    69 CSenApplicationContext& CSenServerContext::OpenApplicationContextL(TSecureId aSecureId)

    70     {

    71     CSenApplicationContext* pCtx = NULL;

    72     // Check if application context already exists, held by this server context

    73     TInt index = iApplications.Find( aSecureId );

    74     if ( index == KErrNotFound )

    75         {

    76         // New application context needs to be created

    77         pCtx = CSenApplicationContext::NewLC(aSecureId, *this );

    78         TUint32* pSecureId = new (ELeave) TUint32(aSecureId);

    79         TInt err = iApplications.Append( pSecureId, pCtx );

    80         if( err )

    81             {

    82             // Append failed: cleanup and leave

    83             delete pSecureId; // de-alloc this orphan

    84             CleanupStack::PopAndDestroy( pCtx );

    85             User::Leave( err ); 

    86             }

    87         else

    88             {

    89             // Remove the new context from cleanup stack, 

    90             // it is now owned by this server context

    91             CleanupStack::Pop( pCtx );

    92             }

    93         }

    94     else

    95         {

    96         // Return the existing application context

    97         pCtx = (CSenApplicationContext*)iApplications.ValueAt( index );

    98         if( !pCtx )

    99             {

   100             // Should NOT occur: map failed => leave with internal error code

   101             User::Leave( KErrSenInternal ); 

   102             }

   103         } 

   104     return *pCtx;

   105     }

   106 

   107 TInt CSenServerContext::CloseApplicationContext(const CSenApplicationContext& aCtx)

   108     {

   109     TInt retVal(KErrNotFound);

   110     if ( aCtx.iClients.Count() == 0 )

   111         {

   112         // Note: RemoveByKey returns KErrNotFound or index of removed item(!)

   113         retVal = iApplications.RemoveByKey( aCtx.SecureId() );

   114         if( retVal != KErrNotFound )

   115             {

   116             retVal = KErrNone;

   117             }

   118         }

   119     else

   120         {

   121         retVal = KErrInUse;

   122         }

   123     return retVal;

   124     }

   125 

   126 // From MSenServerContext:

   127 /*

   128 SenContext::TContextType CSenServerContext::Type() const

   129     {

   130     return SenContext::EMessageContext;

   131     }

   132        

   133 SenContext::TContextDirection CSenServerContext::Direction() const

   134     {

   135     return CSenContext::Direction();

   136     }

   137        

   138 TInt CSenServerContext::Add(const TDesC8& aKey, const TDesC8& aValue)

   139     {

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

   141     }

   142        

   143 TInt CSenServerContext::Update(const TDesC8& aKey, const TDesC8& aValue)

   144     {

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

   146     }

   147        

   148 const TDesC8* CSenServerContext::GetDesC8L(const TDesC8& aKey)

   149     {

   150     return CSenContext::GetDesC8L( aKey );

   151     }

   152        

   153 TInt CSenServerContext::Add(const TDesC8& aKey, TInt aValue)

   154     {

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

   156     }

   157        

   158 TInt CSenServerContext::Update(const TDesC8& aKey, TInt aValue)

   159     {

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

   161     }

   162        

   163 const TInt* CSenServerContext::GetIntL(const TDesC8& aKey)

   164     {

   165     return CSenContext::GetIntL( aKey );

   166     }

   167        

   168 TInt CSenServerContext::Add(const TDesC8& aKey, CSenElement* aValue)

   169     {

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

   171     }

   172        

   173 TInt CSenServerContext::Update(const TDesC8& aKey, CSenElement* aValue)

   174     {

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

   176     }

   177        

   178 const CSenElement* CSenServerContext::GetSenElementL(const TDesC8& aKey)

   179     {

   180     return CSenContext::GetSenElementL( aKey );

   181     }

   182        

   183 TInt CSenServerContext::Add(const TDesC8& aKey, TAny* aValue)

   184     {

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

   186     }

   187        

   188 TInt CSenServerContext::Update(const TDesC8& aKey, TAny* aValue)

   189     {

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

   191     }

   192        

   193 TAny* CSenServerContext::GetAny(const TDesC8& aKey)

   194     {

   195     return CSenContext::GetAny( aKey );

   196     }

   197        

   198 TInt CSenServerContext::Remove(const TDesC8& aKey) 

   199     {

   200     return CSenContext::Remove(aKey);

   201     }

   202 

   203 TInt CSenServerContext::Count() const

   204     {

   205     return CSenContext::Count();

   206     }

   207 

   208 TPtrC8 CSenServerContext::KeyAtL(TInt aIndex)

   209     {

   210     return CSenContext::KeyAtL(aIndex);

   211     }

   212 

   213 void CSenServerContext::Reset()

   214     {

   215     CSenContext::Reset();

   216     }

   217     

   218 CSenSoapMessage* CSenServerContext::GetCurrentSoapMessage() // DEPRECATED: 

   219     {

   220     CSenSoapMessage* pSoapMessage = NULL;

   221     

   222     TInt index = iItems.Find( KSenCtxKeyCurrentSoapMessage );

   223     if ( index != KErrNotFound )

   224         {

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

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

   227         }

   228     return pSoapMessage;

   229     }

   230     

   231 TPtrC8 CSenServerContext::GetMessage()

   232     {

   233     TInt index = iItems.Find( KSenCtxKeyCurrentMessageAsDesc );

   234     if ( index != KErrNotFound )

   235         {

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

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

   238         return *desc;

   239         }

   240     return KNullDesC8();

   241     }

   242     

   243 TInt CSenServerContext::Add(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   244     {

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

   246     }

   247     

   248 TInt CSenServerContext::Update(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   249     {

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

   251     }

   252     

   253 const CSenSoapEnvelope* CSenServerContext::GetSenSoapEnvelopeL(const TDesC8& aKey)

   254     {

   255     TInt index = iItems.Find( aKey );

   256     if ( index != KErrNotFound )

   257         {

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

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

   260         return envelope;

   261         }

   262     return NULL;

   263     }

   264     

   265 MSenMessage* CSenServerContext::Message()

   266     {

   267     TInt index = iItems.Find( KSenCtxKeyMessage );

   268     if ( index != KErrNotFound )

   269         {

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

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

   272         }

   273     return NULL;

   274     }

   275     

   276 TInt CSenServerContext::SetMessage(MSenMessage* apMessage, TBool aOwned)

   277     {

   278     TInt leaveCode(KErrNone);

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

   280 

   281     if( leaveCode != KErrNone ) 

   282         {

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

   284         return leaveCode;

   285         }

   286         

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

   288     if( retCode != KErrNone && aOwned )

   289         {

   290         delete pItem; // delete the orphan item

   291         } 

   292     return retCode;

   293     }

   294     

   295     

   296 CSenChunk* CSenServerContext::Chunk()

   297     {

   298     TInt index = iItems.Find( KSenCtxKeyChunk );

   299     if ( index != KErrNotFound )

   300         {

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

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

   303         }

   304     return NULL;

   305     }

   306     

   307 TInt CSenServerContext::SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned)

   308     {

   309     TInt leaveCode(KErrNone);

   310     

   311     CSenContextItem* pItem = NULL;

   312     if( aOwned )

   313         {

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

   315         }

   316     else // chunk is not to be owned

   317         {

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

   319         }

   320 

   321     if( leaveCode != KErrNone ) 

   322         {

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

   324         return leaveCode;

   325         }

   326         

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

   328     if( retCode != KErrNone && aOwned )

   329         {

   330         delete pItem; // delete the orphan item

   331         } 

   332     return retCode;

   333     }

   334     

   335 

   336 TInt CSenServerContext::SetProperties(MSenProperties* apProperties, TBool aOwned)

   337     {

   338     if( !apProperties )

   339         {

   340         return KErrArgument;

   341         }

   342         

   343     TInt retCode(KErrNone);

   344     if ( aOwned )

   345         {

   346         delete ipOwnedTp;

   347         ipOwnedTp = NULL;

   348         ipOwnedTp = apProperties;

   349         }

   350     else

   351         {

   352         

   353         CSenContextItem* pItem = NULL;

   354         TInt leaveCode(KErrNone);

   355 //        if( aOwned )

   356 //            {

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

   358 //            }

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

   360 //            {

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

   362 //            }

   363 

   364         if( leaveCode != KErrNone ) 

   365             {

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

   367             return leaveCode;

   368             }

   369             

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

   371         if( retCode != KErrNone && aOwned )

   372             {

   373             delete pItem; // delete the orphan item

   374             } 

   375         }

   376     return retCode;

   377     }

   378 

   379 

   380 MSenProperties* CSenServerContext::Properties()

   381     {

   382     if( ipOwnedTp )

   383         {

   384         return ipOwnedTp;

   385         }

   386     else

   387         {

   388         TInt index = iItems.Find( KSenCtxKeyMessageProperties );

   389         if ( index != KErrNotFound )

   390             {

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

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

   393                 {

   394                 MSenProperties* pProperties = (MSenProperties*)pItem;

   395                 return pProperties;

   396                 }

   397             }

   398         return NULL;

   399         }

   400     }

   401 

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

   403 TInt CSenServerContext::Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   404     {

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

   406         {

   407         return KErrAlreadyExists;

   408         }

   409 

   410     TInt leaveCode(KErrNone);

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

   412     if( leaveCode != KErrNone ) 

   413         {

   414         return leaveCode;

   415         }

   416 

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

   418     if( retCode != KErrNone )

   419         {

   420         delete pItem;

   421         }

   422     return retCode;

   423     }

   424     

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

   426 TInt CSenServerContext::Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   427     {

   428     TInt leaveCode(KErrNone);

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

   430     if( leaveCode != KErrNone ) 

   431         {

   432         return leaveCode;

   433         }

   434 

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

   436     if( retCode != KErrNone && aOwned )

   437         {

   438         delete pItem;

   439         }

   440     return retCode;    

   441     }

   442     

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

   444 MSenMessage* CSenServerContext::GetMessage(const TDesC8& aKey)

   445     {

   446     TInt index = iItems.Find(aKey);

   447     if ( index != KErrNotFound )

   448         {

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

   450         if(pItem)

   451             {

   452             return &pItem->ToSenMessageL();

   453             }

   454         }

   455     return NULL;    

   456     }

   457  

   458 // private helper method(s):

   459 CSenContextItem* CSenServerContext::MessageToItem(MSenMessage* apMessage, TBool aOwned, TInt& aError)

   460     {

   461     aError = KErrNone;

   462     CSenContextItem* pItem = NULL;

   463     if( aOwned )

   464         {

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

   466             {

   467             CSenMessageBase* msgBase = (CSenMessageBase*) apMessage;

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

   469             }

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

   471             {

   472             CSenSoapEnvelope2* msgSoap2 = (CSenSoapEnvelope2*) apMessage;

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

   474             }

   475         else 

   476             {

   477             aError = KErrNotSupported;

   478             return NULL;

   479             }

   480         }

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

   482         {

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

   484         }

   485     return pItem;        

   486     } 

   487     

   488 TInt CSenServerContext::SetDirection( SenContext::TContextDirection aDirection )

   489     {

   490     CSenContext::SetDirection( aDirection );

   491     return KErrNone;

   492     }

   493 

   494 const CSenXmlReader* CSenServerContext::GetParser()

   495     {

   496     return CSenContext::GetParser();

   497     }

   498 */       

   499 // End of file

   500