--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsconnectionagent/src/senconnagentsession.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,298 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:         
+*
+*/
+
+
+
+
+#ifdef __ENABLE_ALR__
+#include <comms-infras/cs_mobility_apiext.h>
+#endif //__ENABLE_ALR__
+
+
+#include "senconnagentsession.h"
+#include "senconnagentserver.h"
+#include "senservicemanagerdefines.h"
+#include "MSenServiceConsumer.h"
+
+#include "MSenAuthenticationProvider.h"
+#include "SenIdentityProvider.h"
+#include "msenservicemanager.h"
+
+#include "msencobrandinginterface.h"
+#include "senchunk.h"
+#include "senxmldebug.h"
+
+CSenConnAgentSession::~CSenConnAgentSession()
+    {
+    
+    }
+
+void CSenConnAgentSession::ServiceL(const RMessage2& aMessage)
+    {
+    switch (aMessage.Function())
+        {
+        case ESenCliServInitialize:
+            {
+            iObserver = static_cast<MSenFilesObserver*>(
+					const_cast<TAny*>(aMessage.Ptr0()));
+            aMessage.Complete(KErrNone);
+            ((CActiveSchedulerWait*)aMessage.Ptr1())->AsyncStop();
+            }
+            break;
+        case ESenCliServTransferProgress:
+            {
+            TTransferProgress transfer;
+            TPckg<TTransferProgress> transferPckg(transfer);
+            aMessage.ReadL(0, transferPckg);
+            HBufC8* buf = HBufC8::NewLC(aMessage.GetDesLengthL(1));
+            TPtr8 bufPtr = buf->Des();
+            aMessage.ReadL(1, bufPtr);
+            aMessage.Complete(KErrNone);
+            if (transfer.iSoap)
+                {
+                iObserver->TransferProgress(transfer.iTxnId,
+                        transfer.iIncoming, *buf, KNullDesC8, 0);
+                }
+            else
+                {
+                iObserver->TransferProgress(transfer.iTxnId,
+                        transfer.iIncoming, KNullDesC8, *buf, transfer.iProgress);
+                }
+            CleanupStack::PopAndDestroy(buf);
+          }
+            break;
+        case ESenCliServAuthInitialize:
+            {
+	        iAuthObserver = static_cast<MSenAuthenticationProvider*>(
+					const_cast<TAny*>(aMessage.Ptr0()));
+	        ((CActiveSchedulerWait*)aMessage.Ptr1())->AsyncStop();
+	        aMessage.Complete(KErrNone);
+            }
+	        break;
+        case ESenCliServCoBrandingInitialize:
+            {
+	        ipCoBrandingObserver = static_cast<MSenCoBrandingObserver*>(
+					const_cast<TAny*>(aMessage.Ptr0()));
+	        ((CActiveSchedulerWait*)aMessage.Ptr1())->AsyncStop();
+	        aMessage.Complete(KErrNone);
+            }
+            break;
+	    case ESenCliServReAuthNeeded:
+	        {
+	    	TInt retVal(KErrNone);
+	    	TRAPD(error, retVal = ReauthenticationNeededL(aMessage));
+	    	if(error)
+	    		{
+	    		retVal = error;
+	    		}
+	    	aMessage.Complete(retVal);
+	    	CActiveSchedulerWait* wait = static_cast<CActiveSchedulerWait*>(
+					const_cast<TAny*>(aMessage.Ptr1()));
+	    	if(wait && wait->IsStarted())
+	    		{
+	    		wait->AsyncStop();
+	    		}
+	    		}
+        	break;
+        case ESenCliServGoNoGo:
+            {
+	    	TInt retValue(KErrNone);
+	    	TRAPD(CBerror, retValue = CoBrandingGoNoGoL(aMessage));
+	    	if(CBerror)
+	    		{
+	    		retValue = CBerror;
+	    		}
+	    	aMessage.Complete(retValue);
+            }
+        	break;
+
+#ifdef __ENABLE_ALR__
+        case ESenCliServMobilityInitialize:
+            {
+            iMobiltyObserver = static_cast<MMobilityProtocolResp*>(
+					const_cast<TAny*>(aMessage.Ptr0()));
+            aMessage.Complete(KErrNone);
+            ((CActiveSchedulerWait*)aMessage.Ptr1())->AsyncStop();                
+            }
+            break;
+        case ESenCliServPrefferedCarrierAvailable:
+            {
+            TInt oldap = aMessage.Int0();
+            TInt newap= aMessage.Int1();
+            
+            TAccessPointInfo oldAPInfo ;
+            oldAPInfo.SetAccessPoint( oldap );
+            TAccessPointInfo newAPInfo ;
+            newAPInfo.SetAccessPoint( newap );
+
+            HBufC8* upgradeBuf = HBufC8::NewLC(10);
+            TPtr8 upgradeBuffer = upgradeBuf->Des();
+            aMessage.ReadL(2, upgradeBuffer); 
+            TBool isUpgrade = (TBool)(*upgradeBuffer.Ptr()) ;
+            CleanupStack::PopAndDestroy(upgradeBuf); 
+            
+            HBufC8* seemlessBuf = HBufC8::NewLC(10);
+            TPtr8 seemlessBuffer = seemlessBuf->Des();
+            aMessage.ReadL(3, seemlessBuffer); 
+            TBool isSeamless = (TBool)(*seemlessBuffer.Ptr()) ;
+            CleanupStack::PopAndDestroy(seemlessBuf); 
+            
+            aMessage.Complete(KErrNone);
+            // check for mobility observer and forward the call to the observer (application)
+            if(iMobiltyObserver)
+                {
+                iMobiltyObserver->PreferredCarrierAvailable(oldAPInfo, newAPInfo, isUpgrade, isSeamless) ;
+                }
+            }
+            break;
+        case ESenCliServNewCarrierActive:
+            {
+            TInt newap = aMessage.Int0();
+            TAccessPointInfo newAPInfo ;
+            newAPInfo.SetAccessPoint( newap );
+            HBufC8* inBuf = HBufC8::NewLC(10);
+            TPtr8 inBuffer = inBuf->Des();
+            aMessage.ReadL(1, inBuffer); 
+            TBool isSeamless = (TBool)(*inBuffer.Ptr()) ;
+            CleanupStack::PopAndDestroy(inBuf); 
+            aMessage.Complete(KErrNone);
+            // check for mobility observer and forward the call to the observer (application)
+            if(iMobiltyObserver)
+                {
+                iMobiltyObserver->NewCarrierActive(newAPInfo, isSeamless) ;
+                }
+            }
+            break;
+        case ESenCliServMobilityError:
+            {
+        	TInt mobilityError = aMessage.Int0();
+            aMessage.Complete(KErrNone);
+            // check for mobility observer and forward the call to the observer (application)
+            if(iMobiltyObserver)
+                {
+                iMobiltyObserver->Error(mobilityError);
+                }
+            }
+            break;
+#endif //__ENABLE_ALR__
+        default:
+            {
+            aMessage.Complete(KErrNotSupported);
+            }
+            break;
+        }
+    }
+
+void CSenConnAgentSession::Disconnect(const RMessage2& aMessage)
+    {
+    CSession2::Disconnect(aMessage);
+    CSenConnAgentServer* server = reinterpret_cast<CSenConnAgentServer*>
+            (Dll::Tls());
+    ASSERT(server);
+    server->DestroyIfInactive();
+    }
+TInt CSenConnAgentSession::CoBrandingGoNoGoL(const RMessage2& aMessage)
+    {
+    TBool* goNoGo = static_cast<TBool*>(
+					const_cast<TAny*>(aMessage.Ptr0()));    
+
+	HBufC8* buf = HBufC8::NewLC(aMessage.GetDesLengthL(1));
+	TPtr8 bufPtr = buf->Des();
+	aMessage.ReadL(1, bufPtr);
+    
+    RBuf8* selectedbrandID = static_cast<RBuf8*>(
+					const_cast<TAny*>(aMessage.Ptr2()));
+
+    if (ipCoBrandingObserver)
+        {
+        *goNoGo = ipCoBrandingObserver->OnGetBrandIdL(*buf,*selectedbrandID);  
+				CleanupStack::PopAndDestroy(buf);        
+        return KErrNone;
+        }
+        
+		CleanupStack::PopAndDestroy(buf);        
+    return KErrGeneral;
+    }
+TInt CSenConnAgentSession::ReauthenticationNeededL(const RMessage2& aMessage)
+	{
+	TInt retVal = KErrNone;
+	TBool providerCreated = EFalse;
+	
+	if(iAuthObserver)
+		{
+		CSenChunk* pSenChunk = CSenChunk::NewLC(KNullDesC());
+		retVal = pSenChunk->OpenChunkFromRMsgL(aMessage,0);
+		
+		if(retVal == KErrNone)
+			{
+	    	CSenIdentityProvider* pIdP = 
+	    		(CSenIdentityProvider*)iAuthObserver->IdentityProviderL();
+	    	
+	    	if(!pIdP)
+	    		{
+	    		TPtrC8 identityProvider;
+	    		retVal = pSenChunk->DescFromChunk(identityProvider);
+	    		
+	    		if(retVal == KErrNone)
+	    			{
+			    	pIdP = CSenIdentityProvider::NewLC(KNullDesC8());
+			    	providerCreated = ETrue;
+			    	CSenXmlReader* pXmlReader = CSenXmlReader::NewLC(KXmlParserMimeType);
+			    	pXmlReader->SetContentHandler( *pIdP );
+			    	pIdP->SetReader(*pXmlReader);
+			    	
+			    	pIdP->ParseL( identityProvider );
+			    	CleanupStack::PopAndDestroy(pXmlReader);
+			    		
+			    	TPtrC8 userName = iAuthObserver->UsernameL();
+			        TPtrC8 password = iAuthObserver->PasswordL();
+			        if(pIdP && userName != KNullDesC8 && password != KNullDesC8 )
+			        	{
+				        retVal = pIdP->SetUserInfoL( userName ,
+											   		 userName ,
+											   		 password );
+			        	}
+	    			}
+	    		}
+	    	
+	    	if(pIdP)
+	    		{
+	    		// Identity provider data retrieved from callback, return it
+	    		HBufC8* desIdP = pIdP->AsXmlL();
+	    		CleanupStack::PushL(desIdP);
+	    		pSenChunk->DescToChunk(*desIdP);
+	    		CleanupStack::PopAndDestroy(desIdP);
+	    		}
+	    	else
+	    		{
+	    		// Identity provider was not passed
+	    		retVal = KErrNotFound;
+	    		}
+	    	
+	    	if(providerCreated)
+	    		{
+	    		CleanupStack::PopAndDestroy(pIdP);
+	    		}
+			}
+		CleanupStack::PopAndDestroy(pSenChunk);
+		}
+	else
+		{
+		retVal = KErrNotReady;
+		}
+	return retVal;
+	}