rtcoutgoingdlg.cpp

再贡献一份基于osip 协议栈的用户代理

		
			hr = m_pIRTCClient->SetPreferredMediaTypes(lSetMedia, fPersist);

			if (FAILED(hr))
			{
				LOGMSGERROR(_T("IRTCClient::SetPreferredMediaTypes(%d) Failed 0x%x"), 
					lSetMedia, hr);
				return hr;
			}

		}
	}

	return hr;
}


/**********************************************************
//@StateStartTunning
//
//@Description
//  Starts the Tunning Wizard
//
//@Args In:     None
//@Args Out:    None
//
//
//*********************************************************/
HRESULT 
CRTCOutgoingDlg::StateStartTunning()
{
	HRESULT hr = S_OK;

	_ASSERTE(NULL != m_pIRTCClient);

	//
	// Send Parent Window
	//

	hr = m_pIRTCClient->InvokeTuningWizard( (OAHWND) m_hWnd);

	if (FAILED(hr))
	{
		LOGMSGERROR(_T("IRTCClient::InvokeTuningWizard Failed 0x%x"), hr);
		return hr;
	}
	
	return hr;
	
}
/**********************************************************
//@QueryInterface
//
//@Description
//  
//  QI
//
//@Args In:     None
//@Args Out:    None
//
//
//*********************************************************/

HRESULT	
CRTCOutgoingDlg::QueryInterface(REFIID iid, 
									 void **ppvObject)
{
	if(iid == IID_IRTCEventNotification)
	{
		
		*ppvObject = static_cast<IRTCEventNotification *> (this);
		AddRef();
		return S_OK;
	}


	if(iid == IID_IUnknown)
	{
		
		*ppvObject = static_cast<IUnknown *> (this);
		AddRef();
		return S_OK;
	}

	else 
	{
	   *ppvObject = NULL;
	   return E_NOINTERFACE;
	}

	return S_OK;
}

// klaus
HRESULT CRTCOutgoingDlg::DoGetProfile(LPTSTR lptstrUser, 
									  LPTSTR lptstrPw, 
									  LPTSTR lptstrURI, 
									  LPTSTR lptstrServer, 
									  LPTSTR lptstrTransport)
{
    HRESULT hr;

    // Find transport 
    long lTransport = 0;

    if (lptstrTransport != NULL)
    {
        if (!_tcsicmp(lptstrTransport, L"UDP"))
        {
            lTransport = RTCTR_UDP;
        }
        else if (!_tcsicmp(lptstrTransport, L"TCP"))
        {
            lTransport = RTCTR_TCP;
        }
        else if (!_tcsicmp(lptstrTransport, L"TLS"))
        {
            lTransport = RTCTR_TLS;
        }
    }

    // Get the RTC client provisioning interface
    IRTCClientProvisioning * pProv = NULL;

    hr = m_pIRTCClient->QueryInterface(
            __uuidof(IRTCClientProvisioning),
            (void **)&pProv);

    if (FAILED(hr))
    {
        // QueryInterface failed
		LOGMSGERROR(_T("DoGetProfile QueryInterface failed 0x%x"), hr);
        return hr;
    }

    // Get the profile
    hr = pProv->GetProfile(
            lptstrUser,           // bstrUserAccount
            lptstrPw,           // bstrUserPassword
            lptstrURI,        // bstrUserURI
            lptstrServer,     // bstrServer
            lTransport,     // lTransport
            0               // lCookie
            );

    SAFE_RELEASE(pProv);

    if (FAILED(hr))
    {
        // GetProfile failed
		LOGMSGERROR(_T("DoGetProfile GetProfile failed 0x%x"), hr);
        return hr;    
    }

    return S_OK;
}

// end klaus


/**********************************************************
//@ RTCEventNotification Interface Implementations
//*********************************************************/

/**********************************************************
//@AddRef
//
//@Description
//  
//  Ref Count
//
//@Args In:     None
//@Args Out:    None
//
//
//*********************************************************/

ULONG 
CRTCOutgoingDlg::AddRef()
{
	
	ULONG ulrefCount = InterlockedIncrement(&m_dwRefCount);
	return ulrefCount;
}


/**********************************************************
//@Release
//
//@Description
//  
//  object release
//
//@Args In:     None
//@Args Out:    None
//
//
//*********************************************************/

ULONG 
CRTCOutgoingDlg::Release()
{

	ULONG ulrefCount = InterlockedDecrement(&m_dwRefCount);


	if(0 == ulrefCount)
	{
		delete this;
	}

	return ulrefCount;
}

/**********************************************************
//@Event
//
//@Description
//  RTC CallBack for Events, the messages are
//  posted to the thread message pump
//
//  
//
//@Args In:     RTC_EVENT , IDispatch
//@Args Out:    HRESULT
//
//
//*********************************************************/

HRESULT
STDMETHODCALLTYPE
CRTCOutgoingDlg::Event(
				      RTC_EVENT RTCEvent,
					  IDispatch * pEvent
					  )

{

	HRESULT hr  = S_OK;

	if (NULL != pEvent) 
	{

		switch (RTCEvent)
		{

		case RTCE_CLIENT:
			hr = 	RTCClientEvent(pEvent);
			break;
		case RTCE_SESSION_STATE_CHANGE:
			hr = 	RTCSessionStateEvent(pEvent);
			break;
		case RTCE_MEDIA:
			hr =   	RTCMediaEvent(pEvent);
			break;	
		case RTCE_PROFILE:
			m_editRegisterStatus.SetWindowText(_T("RTCE_PROFILE received ..."));
			hr =   	RTCProfileEvent(pEvent);
			break;
		case RTCE_REGISTRATION_STATE_CHANGE:
			hr =   	RTCRegistrationStateEvent(pEvent);
			break;
		default:
			break;
		}


	}

    return hr;
}


/**********************************************************
//@ RTC Event Parsers
//*********************************************************/

/**********************************************************
//@RTCClientEvent
//
//@Description
//
// No Parsing
//
//@Args In:     
//@Args Out:    
//
//
//*********************************************************/

HRESULT 
CRTCOutgoingDlg::RTCClientEvent(IDispatch *pIDispatch)
{
	HRESULT               hr            = S_OK;	
	IRTCClientEvent      *pIClientEvent = NULL;
	RTC_CLIENT_EVENT_TYPE EventType;

	hr = pIDispatch->QueryInterface(IID_IRTCClientEvent,
									reinterpret_cast<void**> (&pIClientEvent)
									);

	if (FAILED(hr))
	{
		LOGMSGERROR(_T("IDispatch::QueryInterface(IRTCClientEvent) Failed 0x%x"), 
			hr);
		return hr;
	}
	
	//
	// Getting the Session Interface
	//

	hr = pIClientEvent->get_EventType(&EventType);

	if (FAILED(hr))
	{
		LOGMSGERROR(_T("IRTCClientEvent::get_EventType Failed 0x%x"), hr);

		pIClientEvent->Release();
		pIClientEvent = NULL;
		return hr;
	}


	if (RTCCET_ASYNC_CLEANUP_DONE  == EventType)
	{
		//
		// When the WndProc gets this message we can 
		// destroy the window
		//

		DBLOGGER(_T("Final Exit ... ASYNC_CLEANUP_DONE\n"));

		SendMessage(WM_RTCCORE_EVENT, (WPARAM) EventType, (LPARAM) NULL);
	}

	if (NULL != pIClientEvent)
	{
		pIClientEvent->Release();
		pIClientEvent = NULL;

	}
	return hr;
}


/**********************************************************
//@RTCSessionStateEvent
//
//@Description
//
//  Destructor
//
//@Args In:     
//@Args Out:    
//
//
//*********************************************************/
HRESULT 
CRTCOutgoingDlg::RTCSessionStateEvent(IDispatch *pIDispatch)
{
	HRESULT hr                                  = S_OK;
	IRTCSessionStateChangeEvent *pISessionState = NULL;
	RTC_SESSION_STATE SessionState;


	hr = pIDispatch->QueryInterface(IID_IRTCSessionStateChangeEvent,
									reinterpret_cast<void**> (&pISessionState)
									);

	if (FAILED(hr))
	{

		LOGMSGERROR(_T("IDispatch::QueryInterface(IRTCSessionStateChangeEvent) Failed 0x%x"), 
			hr);
		return hr;
	}
	

	hr = pISessionState->get_State(&SessionState);

	if (FAILED(hr))
	{
		LOGMSGERROR(_T("IRTCSessionStateChangeEvent::get_State Failed 0x%x"), hr);

		pISessionState->Release();
		pISessionState = NULL;
		return hr;
	}
		

	switch(SessionState)
	{
	case RTCSS_IDLE: break;
	case RTCSS_INCOMING:
	{
		if ( m_pIRTCSession != NULL) 
		{
			// there is already an active session
			// ignore the incoming call
			pISessionState->Release();
			pISessionState = NULL;
			m_ctrlEditStatus.SetWindowText(_T("Incoming Call... ignored"));
			return S_OK;
		}

		hr = pISessionState->get_Session(&m_pIRTCSession);

		if (FAILED(hr))
		{
			LOGMSGERROR(_T("IRTCSessionStateChangeEvent::get_Session Failed 0x%x"), hr);
			pISessionState->Release();
			pISessionState = NULL;
			return hr;
		}

		m_ctrlEditStatus.SetWindowText(_T("Incoming Call..."));
		Beep(1000,50);
		Beep(1500,50);
		Beep(1000,50);
		Sleep(1000);
		Beep(1000,50);
		Beep(1500,50);
		Beep(1000,50);
		Sleep(1000);
		m_ctrlEditStatus.SetWindowText(_T("Incoming Call...Auto Answered"));
		StateSessionControl(STO_ANSWER);

		break;
	}
	case RTCSS_ANSWERING: 	
		m_ctrlEditStatus.SetWindowText(_T("Answering ..."));
		break;
	case RTCSS_INPROGRESS:
		m_ctrlEditStatus.SetWindowText(_T("In Progress ..."));
		StateConnectIDC(VARIANT_FALSE);
		StateSipIDC(VARIANT_FALSE);
		StateDisconnectIDC(VARIANT_TRUE);
		break;
	case RTCSS_CONNECTED :
		{
			StateConnectIDC(VARIANT_FALSE);
			StateSipIDC(VARIANT_FALSE);
			StateDisconnectIDC(VARIANT_TRUE);
			m_ctrlEditStatus.SetWindowText(_T("Connected ..."));
			break;
		}
	case RTCSS_DISCONNECTED:
		{
			//
			// Disabling call-control related UI
			//

			StateSipIDC(VARIANT_TRUE);

			StateDisconnectIDC(VARIANT_FALSE);
			StateConnectIDC(VARIANT_TRUE);
			StateConnectIDCVisible(VARIANT_TRUE);
			StateTuneIDC(VARIANT_TRUE);

			m_ctrlEditStatus.SetWindowText(_T("Disconnected ..."));
			m_ctrlEditStatus.SetWindowText(_T("Ready ..."));

			//
			// Releasing the Session Interface
			//
			m_pIRTCSession->Release();
			m_pIRTCSession = NULL;

			break;
		}
	default : 
		{
			pISessionState->Release();
			pISessionState = NULL;
			return E_UNEXPECTED;
		}

	}

	if (NULL != pISessionState)
	{

		pISessionState->Release();
		pISessionState = NULL;

	}
	
	return hr;
}

/**********************************************************
//@RTCMediaEvent
//
//@Description
//
//  Parser for Media Event
//
//  here we start the video window in a specific 
//  window location of the dialog box, we can 
//  only do this if the video stream has started
//  if an application doesnt care about setting 
//  the video window coordinated you can get the
//  video window and put_AutoShow(TRUE) , this will
//  make the video window automatically visible when
//  the stream has started. 
//
//
//@Args In:     IDispatch Event Interface
//@Args Out:    HRESULT
//
//
//*********************************************************/

HRESULT 
CRTCOutgoingDlg::RTCMediaEvent(IDispatch *pIDispatch)
{
	HRESULT hr                          = S_OK;
	IRTCMediaEvent        *pIMediaEvent = NULL;
	LONG                   lMediaType   = 0;
	HWND                   hwdVideoRecv , hwdVideoSend;
	RTC_MEDIA_EVENT_TYPE   EventType;

	hr = pIDispatch->QueryInterface(IID_IRTCMediaEvent,
									reinterpret_cast<void**> (&pIMediaEvent)
									);

	if (FAILED(hr))
	{

		LOGMSGERROR(_T("IDispatch::QueryInterface(IRTCMediaEvent) Failed 0x%x"), hr);
		return hr;
	}

	pIMediaEvent->get_MediaType(&lMediaType);
	pIMediaEvent->get_EventType(&EventType);

	if ( (lMediaType == RTCMT_VIDEO_RECEIVE) && (EventType == RTCMET_STARTED) )
	{

		   RECT    rectPos;				

		   hr = m_pIRTCClient->get_IVideoWindow(  RTCVD_RECEIVE , &m_pIRecvVideo);

			if (SUCCEEDED(hr))
			{
				CString cstrText;

				hr = m_pIRecvVideo->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS);
        
				if(FAILED(hr))
				{
					LOGMSGERROR(_T("IVideoWindow::put_WindowStyle() Failed 0x%x"), hr);
										
					pIMediaEvent->Release();
					pIMediaEvent = NULL;

					return hr;
				}
        
				hr = m_pIRecvVideo->put_Owner((OAHWND) m_hWnd);
        
				if(FAILED(hr))
				{
					
					LOGMSGERROR(_T("IVideoWindow::put_Owner() Failed 0x%x"), hr);
										
					pIMediaEvent->Release();
					pIMediaEvent = NULL;

					return hr;
				}

				
				GetDlgItem( IDC_VRECVS, &hwdVideoRecv );

				::GetClientRect(hwdVideoRecv, &rectPos);

		        hr = m_pIRecvVideo->SetWindowPosition(
			    rectPos.left   + RECVVID_LEFT,
				rectPos.top    + RECVVID_TOP,
				rectPos.right  - RECVVID_RIGHT,