FCL/sf/mw/ipappprotocols: comparison Msrp/MsrpServer/src/CMSRPConnectionManager.cpp

equal deleted inserted replaced

-:505ad3f0ce5c
+:cdb720e67852
 // CLASS HEADER
 #include "CMSRPConnectionManager.h"
 #include "MSRPCommon.h"
 #include "CMSRPConnection.h"
 #include "CMSRPConnListener.h"
-#include <CommDbConnPref.h>
+#undef __SERIES60_
 #if defined(__SERIES60_)
 #include <extendedconnpref.h>
 #endif
 // INTERNAL INCLUDES
 // -----------------------------------------------------------------------------
 // Constructor
 // -----------------------------------------------------------------------------
 //
 CMSRPConnectionManager::CMSRPConnectionManager( const TUint32 aIapID, MMSRPConnectionManagerObserver& aServer )
 : iIapID( aIapID ), iObserver( aServer )
 {
 MSRPLOG( "CMSRPConnectionManager::CMSRPConnectionManager enter" )
 MSRPLOG( "CMSRPConnectionManager::CMSRPConnectionManager exit" )
 }
 // CMSRPConnectionManager::ConstructL
 // -----------------------------------------------------------------------------
 //
 void CMSRPConnectionManager::ConstructL( )
 	{
 MSRPLOG( "CMSRPConnectionManager::ConstructL enter" )
 	TInt status = iSocketServer.Connect();
 	if (status != KErrNone)
 	    {
 	    //iObserver->HandleError(ESocketServerStartFailed, status , *this );//need to pass connmngr as server handles many connmngrs
 	    //User::Leave(status);
 	    User::Leave(MMSRPConnectionManagerObserver::ESocketServerStartFailed); //leave code instead of observer call, as in constructl itself
 	    }
 status = StartInterface();
 if (status != KErrNone)
 {
 User::Leave(MMSRPConnectionManagerObserver::EInterfaceStartFailed);
 }
 MSRPLOG( "CMSRPConnectionManager::ConstructL exit" )
 	}
 CMSRPConnectionManager::~CMSRPConnectionManager()
 	{
 MSRPLOG( "CMSRPConnectionManager::~CMSRPConnectionManager enter" )
 	delete iConnListener;
 	iConnectionArray.ResetAndDestroy();
 	iConnectionArray.Close();
 	iHostResolver.Close();
 	iConnection.Close();
 	iSocketServer.Close();
 	MSRPLOG( "CMSRPConnectionManager::~CMSRPConnectionManager exit" )
 	}
 // -----------------------------------------------------------------------------
 {
 //iObserver->HandleError( MMSRPConnectionManagerObserver::EAddressResolveError, err , *this );
 User::Leave(MMSRPConnectionManagerObserver::EAddressResolveError);
 }
 hostAddr.SetPort(aPort);
 	MMSRPConnection* connection = CheckConnection( hostAddr, FALSE );
 	if ( !connection )
 		{
 connection = CMSRPConnection::NewL( hostAddr, *this );
 CleanupDeletePushL(connection);//as M class
 //CleanupStack::PushL( connection );
 iConnectionArray.AppendL( connection );
 CleanupStack::Pop( );
 		}
 MSRPLOG( "CMSRPConnectionManager::getConnectionL exit" )
 	return *connection;
 	}
 // -----------------------------------------------------------------------------
 // CMSRPConnectionManager::StartListener
 MSRPLOG( "CMSRPConnectionManager::ListenL enter" )
 if(!iConnListener)
 {
 iConnListener = CMSRPConnListener::NewL(*this);
 }
 TRAPD(err,iConnListener->ListenL());
 if(err != KErrNone)
 {
 //delete iConnListener;
 //iConnListener = NULL;
 //iObserver->HandleError( MMSRPConnectionManagerObserver::EListenerStartError, err , *this );//communicate to server to trigger cleanup
 /*subsession can propagate to server (based on error), which handles error*/
 User::Leave(MMSRPConnectionManagerObserver::EListenerStartError); //listenL leaves to subsession
 }
 MSRPLOG( "CMSRPConnectionManager::ListenL exit" )
 }
 // -----------------------------------------------------------------------------
 // CMSRPConnectionManager::ListenCancel
 //connection listencancel calls mngr cancel if one registered subsession observer or state notlistening
 //
 void CMSRPConnectionManager::ListenCancel(MMSRPConnection* aConnection)
 {
 MSRPLOG( "CMSRPConnectionManager::ListenCancel enter" )
 if(iConnListener)
 {
 iConnListener->ListenCancel();
 }
 Remove(aConnection);
 MSRPLOG( "CMSRPConnectionManager::ListenCancel exit" )
 }
 // -----------------------------------------------------------------------------
 // CMSRPConnectionManager::ListenerState
 //
 void CMSRPConnectionManager::ListenerStateL( TInt aNewState, RSocket* aDataSocket, TInt aStatus )
 {
 MSRPLOG( "CMSRPConnectionManager::ListenerStateL enter" )
 if (aNewState == MMSRPListener::EListenAccepted)
 {
 TInetAddr remoteAddr;
 aDataSocket->RemoteName(remoteAddr);
 MMSRPConnection* connection = CheckConnection( remoteAddr, TRUE );
 if ( !connection )
 {
 iConnListener->ListenCompletedL(FALSE);
 }
 else
 {
 iConnListener->ListenCompletedL(TRUE);
 TRAPD(err, connection->ConnectionEstablishedL(MMSRPConnection::EConnected, aDataSocket, aStatus ));
 if(err!=KErrNone)
 //non leaving on error, introduce separate fn later
 connection->ConnectionEstablishedL(MMSRPConnection::EError, aDataSocket, err );
 }
 }
 else if (aNewState == MMSRPListener::ETimedOut || aNewState == MMSRPListener::ETerminate)
 {
 delete iConnListener;
 iConnListener = NULL;
 else if (aNewState == MMSRPListener::EListenPortError)
 {
 delete iConnListener;
 iConnListener = NULL;
 User::Leave(MMSRPConnectionManagerObserver::EListenPortFailed);
 //leave here, propagate upto msrpscheduler, in scheduler error intimate server to handle the error
 //instead could intimate observer (server) directly
 //iObserver->HandleError( MMSRPConnectionManagerObserver::EListenPortFailed, aStatus , *this );
 }
 MSRPLOG( "CMSRPConnectionManager::ListenerStateL exit" )
 }
 			{
 			return iConnectionArray[ i ];
 			}
 		}
 	MSRPLOG( "CMSRPConnectionManager::CheckConnection exit" )
 	return NULL;
 	}
 // -----------------------------------------------------------------------------
 // CMSRPConnectionManager::StartInterfaceL
 // Activates PDP ctx
 // -----------------------------------------------------------------------------
 //
 TInt CMSRPConnectionManager::StartInterface()
 {
 MSRPLOG( "CMSRPConnectionManager::StartInterface enter" )
 TInt status = KErrNone;
 //if( !iConnection.SubSessionHandle() )
 {
 status = iConnection.Open( iSocketServer );
 }
 #if defined(__SERIES60_)
 if (status == KErrNone)
 {
 TConnPrefList  prefList;
 TExtendedConnPref extPrefs;
 extPrefs.SetIapId( iIapID );
 TRAP(status, prefList.AppendL(&extPrefs));
 if (status == KErrNone)
 {
 status = iConnection.Start( prefList );
 }
 }
 #else
 if (status == KErrNone)
 {
-TCommDbConnPref prefs;
+iConnectionPreferences.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
-prefs.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
+iConnectionPreferences.SetDirection( ECommDbConnectionDirectionUnknown );
-prefs.SetDirection( ECommDbConnectionDirectionUnknown );
+iConnectionPreferences.SetIapId( iIapID );
-prefs.SetIapId( iIapID );
+status = iConnection.Start( iConnectionPreferences );
-status = iConnection.Start( prefs );
+}
-}
+#endif
-#endif
 MSRPLOG( "CMSRPConnectionManager::StartInterface exit" )
 return status;
+}
+// -----------------------------------------------------------------------------
+// CMSRPConnectionManager::ReStartInterface
+// -----------------------------------------------------------------------------
+//
+TInt CMSRPConnectionManager::ReStartInterface()
+{
+iConnection.Close();
+iSocketServer.Close();
+TInt error = iSocketServer.Connect();
+if ( !error )
+{
+error = StartInterface();
+}
+return error;
 }
 // -----------------------------------------------------------------------------
 // CMSRPConnectionManager::ResolveIPAddressL
 // -----------------------------------------------------------------------------
 {
 MSRPLOG( "CMSRPConnectionManager::ResolveIPAddressL enter" )
 //RHostResolver hostResolver;
 TNameEntry entry;
 TBuf< KMaxLengthOfUrl > hostAddr;
 if( !iHostResolver.SubSessionHandle() )
 {
 User::LeaveIfError( iHostResolver.Open( iSocketServer, KAfInet,
 KProtocolInetTcp, iConnection ));
 }
 //CleanupClosePushL( hostResolver );
 hostAddr.Copy( aHost );
 User::LeaveIfError( iHostResolver.GetByName( hostAddr, entry ) );
 if ( !TInetAddr::Cast( entry().iAddr ).IsWildAddr() )
 {
 aAddress = TInetAddr::Cast( entry().iAddr );
 return;
 }
 /* Open an RSocket and find its address */
 RSocket socket;
 User::LeaveIfError(socket.Open(iSocketServer, KAfInet, KSockDatagram, KProtocolInetUdp,iConnection));
 CleanupClosePushL(socket);
 TSoInetInterfaceInfo networkInfo;
 TPckg<TSoInetInterfaceInfo> opt(networkInfo);
 User::LeaveIfError(socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl));
 TSoInetIfQuery query;
 TPckg<TSoInetIfQuery> queryBuf(query);
 TInt res = KErrNone;
 do
 {
 res = socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt);
 if (!res && opt().iState == EIfUp)
 {
 query.iName = opt().iName;
 void CMSRPConnectionManager::Remove(MMSRPConnection* aConn)
 {
 MSRPLOG( "CMSRPConnectionManager::Remove connection enter" )
 TInt index = iConnectionArray.Find(aConn);
 delete iConnectionArray[index];
 iConnectionArray.Remove(index);
 MSRPLOG( "CMSRPConnectionManager::Remove connection exit" )
 }
 RSocketServ& CMSRPConnectionManager::SocketServer()
 {
 MSRPLOG( "CMSRPConnectionManager::SocketServer fetch enter" )
 MSRPLOG( "CMSRPConnectionManager::SocketServer fetch exit" )
 return iSocketServer;
 }
 RConnection& CMSRPConnectionManager::SocketServerConn()
 {
 MSRPLOG( "CMSRPConnectionManager::SocketServerConn fetch enter" )
 MSRPLOG( "CMSRPConnectionManager::SocketServerConn fetch exit" )
 return iConnection;
 }
 /*
 TBool CMSRPConnectionManager::MatchIapId(TUint32 aIapID)
 {
 return (aIapID == iIapID);
 }
 */

branch	MSRP_FrameWork
changeset 58	cdb720e67852
parent 25	505ad3f0ce5c
child 60	7634585a4347