1418 lines
34 KiB
C++
1418 lines
34 KiB
C++
// File: imanager.cpp
|
||
|
||
#include "precomp.h"
|
||
|
||
extern "C"
|
||
{
|
||
#include "t120.h"
|
||
}
|
||
#include <version.h>
|
||
#include <confcli.h>
|
||
#include "icall.h"
|
||
#include "icall_in.h"
|
||
#include "imanager.h"
|
||
#include "ichnlvid.h"
|
||
#include "isysinfo.h"
|
||
#include <tsecctrl.h>
|
||
#include <imbft.h>
|
||
#include <objbase.h>
|
||
#include <regentry.h>
|
||
|
||
#include <initguid.h>
|
||
// GUID to receive userdata from "callto:" via INmCall::GetUserData
|
||
//
|
||
// {068B0780-718C-11d0-8B1A-00A0C91BC90E}
|
||
DEFINE_GUID(GUID_CallToUserData,
|
||
0x068b0780, 0x718c, 0x11d0, 0x8b, 0x1a, 0x0, 0xa0, 0xc9, 0x1b, 0xc9, 0x0e);
|
||
|
||
|
||
class CH323ChannelEvent
|
||
{
|
||
private:
|
||
ICommChannel *m_pIChannel;
|
||
IH323Endpoint *m_lpConnection;
|
||
DWORD m_dwStatus;
|
||
|
||
public:
|
||
static DWORD ms_msgChannelEvent;
|
||
|
||
CH323ChannelEvent(ICommChannel *pIChannel,
|
||
IH323Endpoint *lpConnection,
|
||
DWORD dwStatus):
|
||
m_pIChannel(pIChannel),
|
||
m_lpConnection(lpConnection),
|
||
m_dwStatus(dwStatus)
|
||
{
|
||
if(!ms_msgChannelEvent)
|
||
{
|
||
ms_msgChannelEvent = RegisterWindowMessage(_TEXT("NetMeeting::H323ChannelEvent"));
|
||
}
|
||
|
||
m_pIChannel->AddRef();
|
||
m_lpConnection->AddRef();
|
||
}
|
||
|
||
~CH323ChannelEvent()
|
||
{
|
||
m_pIChannel->Release();
|
||
m_lpConnection->Release();
|
||
}
|
||
|
||
|
||
ICommChannel* GetChannel() { return m_pIChannel; }
|
||
IH323Endpoint* GetEndpoint() { return m_lpConnection; }
|
||
DWORD GetStatus() { return m_dwStatus; }
|
||
|
||
};
|
||
|
||
//static
|
||
DWORD CH323ChannelEvent::ms_msgChannelEvent = 0;
|
||
|
||
static HRESULT OnNotifyConferenceCreated(IUnknown *pManagerNotify, PVOID pv, REFIID riid);
|
||
static HRESULT OnNotifyCallCreated(IUnknown *pManagerNotify, PVOID pv, REFIID riid);
|
||
|
||
GUID g_csguidRosterCaps = GUID_CAPS;
|
||
GUID g_csguidSecurity = GUID_SECURITY;
|
||
GUID g_csguidMeetingSettings = GUID_MTGSETTINGS;
|
||
GUID g_csguidUserString = GUID_CallToUserData;
|
||
GUID g_csguidNodeIdTag = GUID_NODEID;
|
||
|
||
// this guid is dynamically created each time we start
|
||
GUID g_guidLocalNodeId;
|
||
|
||
|
||
|
||
CH323UI* g_pH323UI = NULL;
|
||
INodeController* g_pNodeController = NULL;
|
||
SOCKADDR_IN g_sinGateKeeper;
|
||
|
||
const TCHAR cszDllHiddenWndClassName[] = _TEXT("OPNCUI_HiddenWindow");
|
||
|
||
|
||
COprahNCUI *COprahNCUI::m_pOprahNCUI = NULL;
|
||
|
||
static const IID * g_apiidCP_Manager[] =
|
||
{
|
||
{&IID_INmManagerNotify}
|
||
};
|
||
|
||
COprahNCUI::COprahNCUI(OBJECTDESTROYEDPROC ObjectDestroyed) :
|
||
RefCount(ObjectDestroyed),
|
||
CConnectionPointContainer(g_apiidCP_Manager, ARRAY_ELEMENTS(g_apiidCP_Manager)),
|
||
m_uCaps(0),
|
||
m_pQoS(NULL),
|
||
m_pPreviewChannel(NULL),
|
||
m_fAllowAV(TRUE),
|
||
m_pAVConnection(NULL),
|
||
m_hwnd(NULL),
|
||
m_pSysInfo(NULL),
|
||
m_pOutgoingCallManager(NULL),
|
||
m_pIncomingCallManager(NULL),
|
||
m_pConfObject(NULL)
|
||
{
|
||
DbgMsg(iZONE_OBJECTS, "Obj: %08X created CNmManager", this);
|
||
|
||
// DllLock() is called by CClClassFactory::CreateInstance
|
||
m_pOprahNCUI = this;
|
||
|
||
ClearStruct(&g_sinGateKeeper);
|
||
g_sinGateKeeper.sin_addr.s_addr = INADDR_NONE;
|
||
|
||
m_pSysInfo = new CNmSysInfo();
|
||
}
|
||
|
||
|
||
COprahNCUI::~COprahNCUI()
|
||
{
|
||
// need to unregister the H323 callback
|
||
// need to unregister the T120 callback
|
||
|
||
delete m_pIncomingCallManager;
|
||
m_pIncomingCallManager = NULL;
|
||
|
||
delete m_pOutgoingCallManager;
|
||
m_pOutgoingCallManager = NULL;
|
||
|
||
if( m_pSysInfo )
|
||
{
|
||
m_pSysInfo->Release();
|
||
m_pSysInfo = NULL;
|
||
}
|
||
|
||
if (m_pConfObject)
|
||
{
|
||
// turn off stream notifications
|
||
if (g_pH323UI)
|
||
{
|
||
IMediaChannelBuilder *pStreamProvider = NULL;
|
||
pStreamProvider = g_pH323UI->GetStreamProvider();
|
||
if (pStreamProvider)
|
||
{
|
||
pStreamProvider->SetStreamEventObj(NULL);
|
||
pStreamProvider->Release();
|
||
}
|
||
}
|
||
|
||
m_pConfObject->Release();
|
||
m_pConfObject = NULL;
|
||
}
|
||
|
||
if (NULL != m_pPreviewChannel)
|
||
{
|
||
m_pPreviewChannel->Release();
|
||
m_pPreviewChannel = NULL;
|
||
}
|
||
|
||
// Shutdown H323
|
||
delete g_pH323UI;
|
||
g_pH323UI = NULL;
|
||
|
||
if (NULL != m_hwnd)
|
||
{
|
||
HWND hwnd = m_hwnd;
|
||
m_hwnd = NULL;
|
||
|
||
#if 0 // if we start leaking th CH323ChannelEvents we may need to reenable this
|
||
MSG msg;
|
||
while (::PeekMessage(&msg, hwnd,
|
||
CH323ChannelEvent::ms_msgChannelEvent,
|
||
CH323ChannelEvent::ms_msgChannelEvent,
|
||
PM_REMOVE))
|
||
{
|
||
CH323ChannelEvent *pEvent = reinterpret_cast<CH323ChannelEvent*>(msg.lParam);
|
||
delete pEvent;
|
||
}
|
||
#endif
|
||
|
||
::DestroyWindow(hwnd);
|
||
}
|
||
|
||
if (0==UnregisterClass(cszDllHiddenWndClassName, GetInstanceHandle()))
|
||
{
|
||
ERROR_OUT(("COprahNCUI::~COprahNCUI - failed to unregister window class"));
|
||
}
|
||
// cleanup the node controller:
|
||
if (NULL != g_pNodeController)
|
||
{
|
||
g_pNodeController->ReleaseInterface();
|
||
g_pNodeController = NULL;
|
||
}
|
||
// Shutdown QoS
|
||
delete m_pQoS;
|
||
m_pQoS = NULL;
|
||
|
||
m_pOprahNCUI = NULL;
|
||
|
||
DbgMsg(iZONE_OBJECTS, "Obj: %08X destroyed CNmManager", this);
|
||
}
|
||
|
||
BSTR COprahNCUI::GetUserName()
|
||
{
|
||
return m_pSysInfo ? m_pSysInfo->GetUserName() : NULL;
|
||
}
|
||
|
||
UINT COprahNCUI::GetOutgoingCallCount()
|
||
{
|
||
return m_pOutgoingCallManager->GetCallCount();
|
||
}
|
||
|
||
VOID COprahNCUI::OnOutgoingCallCreated(INmCall* pCall)
|
||
{
|
||
// notify the UI about this outgoing call
|
||
NotifySink(pCall, OnNotifyCallCreated);
|
||
|
||
if (!m_pConfObject->IsConferenceCreated())
|
||
{
|
||
m_pConfObject->OnConferenceCreated();
|
||
NotifySink((INmConference*) m_pConfObject, OnNotifyConferenceCreated);
|
||
}
|
||
}
|
||
|
||
VOID COprahNCUI::OnOutgoingCallCanceled(COutgoingCall* pCall)
|
||
{
|
||
m_pOutgoingCallManager->RemoveFromList(pCall);
|
||
}
|
||
|
||
VOID COprahNCUI::OnIncomingCallAccepted()
|
||
{
|
||
if (!m_pConfObject->IsConferenceCreated())
|
||
{
|
||
m_pConfObject->OnConferenceCreated();
|
||
NotifySink((INmConference*) m_pConfObject, OnNotifyConferenceCreated);
|
||
}
|
||
}
|
||
|
||
VOID COprahNCUI::OnIncomingCallCreated(INmCall* pCall)
|
||
{
|
||
NotifySink(pCall, OnNotifyCallCreated);
|
||
}
|
||
|
||
VOID COprahNCUI::CancelCalls()
|
||
{
|
||
m_pOutgoingCallManager->CancelCalls();
|
||
m_pIncomingCallManager->CancelCalls();
|
||
}
|
||
|
||
BOOL COprahNCUI::AcquireAV(IH323Endpoint* pConnection)
|
||
{
|
||
if (NULL == m_pAVConnection)
|
||
{
|
||
m_pAVConnection = pConnection;
|
||
TRACE_OUT(("AV acquired"));
|
||
return TRUE;
|
||
}
|
||
TRACE_OUT(("AV not acquired"));
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL COprahNCUI::ReleaseAV(IH323Endpoint* pConnection)
|
||
{
|
||
if (m_pAVConnection == pConnection)
|
||
{
|
||
m_pAVConnection = NULL;
|
||
TRACE_OUT(("AV released"));
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
|
||
HRESULT COprahNCUI::AllowH323(BOOL fAllowAV)
|
||
{
|
||
m_fAllowAV = fAllowAV;
|
||
if (m_pConfObject->IsConferenceActive())
|
||
{
|
||
// Force a roster update
|
||
CONF_HANDLE hConf = m_pConfObject->GetConfHandle();
|
||
if (NULL != hConf)
|
||
{
|
||
ASSERT(g_pNodeController);
|
||
hConf->UpdateUserData();
|
||
}
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
CREQ_RESPONSETYPE COprahNCUI::OnH323IncomingCall(IH323Endpoint* pConnection,
|
||
P_APP_CALL_SETUP_DATA lpvMNMData)
|
||
{
|
||
CREQ_RESPONSETYPE resp = m_pIncomingCallManager->OnIncomingH323Call(this, pConnection, lpvMNMData);
|
||
|
||
if ((CRR_REJECT == resp) ||
|
||
(CRR_BUSY == resp) ||
|
||
(CRR_SECURITY_DENIED == resp))
|
||
{
|
||
ReleaseAV(pConnection);
|
||
}
|
||
|
||
return resp;
|
||
}
|
||
|
||
|
||
VOID COprahNCUI::OnH323Connected(IH323Endpoint * lpConnection)
|
||
{
|
||
DebugEntry(COprahNCUI::OnH323Connected);
|
||
|
||
if (!m_pOutgoingCallManager->OnH323Connected(lpConnection))
|
||
{
|
||
m_pIncomingCallManager->OnH323Connected(lpConnection);
|
||
}
|
||
|
||
DebugExitVOID(COprahNCUI::OnH323Connected);
|
||
}
|
||
|
||
VOID COprahNCUI::OnH323Disconnected(IH323Endpoint * lpConnection)
|
||
{
|
||
DebugEntry(COprahNCUI::OnH323Disconnected);
|
||
|
||
if (!m_pOutgoingCallManager->OnH323Disconnected(lpConnection))
|
||
{
|
||
m_pIncomingCallManager->OnH323Disconnected(lpConnection);
|
||
}
|
||
|
||
m_pConfObject->OnH323Disconnected(lpConnection, IsOwnerOfAV(lpConnection));
|
||
|
||
ReleaseAV(lpConnection);
|
||
|
||
DebugExitVOID(COprahNCUI::OnH323Disconnected);
|
||
}
|
||
|
||
VOID COprahNCUI::OnT120ChannelOpen(ICommChannel *pIChannel, IH323Endpoint * lpConnection, DWORD dwStatus)
|
||
{
|
||
DebugEntry(COprahNCUI::OnT120ChannelOpen);
|
||
|
||
m_pOutgoingCallManager->OnT120ChannelOpen(pIChannel, lpConnection, dwStatus);
|
||
|
||
DebugExitVOID(COprahNCUI::OnT120ChannelOpen);
|
||
}
|
||
|
||
|
||
VOID COprahNCUI::OnVideoChannelStatus(ICommChannel *pIChannel, IH323Endpoint * lpConnection, DWORD dwStatus)
|
||
{
|
||
DebugEntry(COprahNCUI::OnVideoChannelStatus);
|
||
|
||
m_pConfObject->OnVideoChannelStatus(pIChannel, lpConnection, dwStatus);
|
||
|
||
DebugExitVOID(COprahNCUI::OnVideoChannelStatus);
|
||
}
|
||
|
||
VOID COprahNCUI::OnAudioChannelStatus(ICommChannel *pIChannel, IH323Endpoint * lpConnection, DWORD dwStatus)
|
||
{
|
||
DebugEntry(COprahNCUI::OnAudioChannelStatus);
|
||
|
||
m_pConfObject->OnAudioChannelStatus(pIChannel, lpConnection, dwStatus);
|
||
|
||
DebugExitVOID(COprahNCUI::OnAudioChannelStatus);
|
||
}
|
||
|
||
BOOL COprahNCUI::GetULSName(CRosterInfo *pri)
|
||
{
|
||
if (FIsLoggedOn())
|
||
{
|
||
RegEntry reULS( ISAPI_KEY _TEXT("\\") REGKEY_USERDETAILS,
|
||
HKEY_CURRENT_USER);
|
||
CUSTRING custrULSName(reULS.GetString(REGVAL_ULS_RES_NAME));
|
||
if ((NULL != (PWSTR)custrULSName) &&
|
||
(L'\0' != ((PWSTR)custrULSName)[0]))
|
||
{
|
||
pri->AddItem(g_cwszULSTag, (PWSTR)custrULSName);
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
VOID COprahNCUI::GetRosterInfo(CRosterInfo *pri)
|
||
{
|
||
RegEntry reULS( ISAPI_KEY _TEXT("\\") REGKEY_USERDETAILS,
|
||
HKEY_CURRENT_USER);
|
||
|
||
// This code is here in addition to the code above to fix bug 3367.
|
||
// Add the single IP address to the list that is obtained by calling
|
||
// gethostname() and then gethostbyname().
|
||
// This shouldn't be detrimental, even though we may end up adding the
|
||
// same IP address that has already been added by the code above.
|
||
// This is because the code that looks for matching IP addresses searches
|
||
// through all of them until it finds a match.
|
||
CHAR szHostName[MAX_PATH];
|
||
if (SOCKET_ERROR != gethostname(szHostName, CCHMAX(szHostName)))
|
||
{
|
||
HOSTENT* phe = gethostbyname(szHostName);
|
||
if (NULL != phe)
|
||
{
|
||
ASSERT(phe->h_addrtype == AF_INET);
|
||
ASSERT(phe->h_length == sizeof(DWORD));
|
||
|
||
struct in_addr in;
|
||
in.s_addr = *((DWORD *)phe->h_addr);
|
||
CHAR szIPAddress[MAX_PATH];
|
||
lstrcpyn(szIPAddress, inet_ntoa(in), CCHMAX(szIPAddress));
|
||
pri->AddItem( g_cwszIPTag, CUSTRING(szIPAddress));
|
||
}
|
||
}
|
||
|
||
// Add the build/version string
|
||
pri->AddItem(g_cwszVerTag, (PWSTR)VER_PRODUCTVERSION_DWSTR);
|
||
if (FIsLoggedOn())
|
||
{
|
||
CUSTRING custrULSName(reULS.GetString(REGVAL_ULS_RES_NAME));
|
||
if ((NULL != (PWSTR)custrULSName) &&
|
||
(L'\0' != ((PWSTR)custrULSName)[0]))
|
||
{
|
||
pri->AddItem(g_cwszULSTag, (PWSTR)custrULSName);
|
||
}
|
||
}
|
||
|
||
CUSTRING custrULSEmail(reULS.GetString(REGVAL_ULS_EMAIL_NAME));
|
||
if ((NULL != (PWSTR)custrULSEmail) &&
|
||
(L'\0' != ((PWSTR)custrULSEmail)[0]))
|
||
{
|
||
pri->AddItem(g_cwszULS_EmailTag, (PWSTR)custrULSEmail);
|
||
}
|
||
|
||
CUSTRING custrULSLocation(reULS.GetString(REGVAL_ULS_LOCATION_NAME));
|
||
if ((NULL != (PWSTR)custrULSLocation) &&
|
||
(L'\0' != ((PWSTR)custrULSLocation)[0]))
|
||
{
|
||
pri->AddItem(g_cwszULS_LocationTag, (PWSTR)custrULSLocation);
|
||
}
|
||
|
||
CUSTRING custrULSPhoneNum(reULS.GetString(REGVAL_ULS_PHONENUM_NAME));
|
||
if ((NULL != (PWSTR)custrULSPhoneNum) &&
|
||
(L'\0' != ((PWSTR)custrULSPhoneNum)[0]))
|
||
{
|
||
pri->AddItem(g_cwszULS_PhoneNumTag, (PWSTR)custrULSPhoneNum);
|
||
}
|
||
}
|
||
|
||
|
||
ULONG COprahNCUI::GetRosterCaps()
|
||
{
|
||
ULONG uCaps = m_uCaps;
|
||
|
||
CNmMember * pMember = m_pConfObject->GetLocalMember();
|
||
if (NULL != pMember)
|
||
{
|
||
DWORD dwFlags = pMember->GetDwFlags();
|
||
if (dwFlags & PF_MEDIA_VIDEO)
|
||
{
|
||
uCaps |= CAPFLAG_VIDEO_IN_USE;
|
||
}
|
||
if (dwFlags & PF_MEDIA_AUDIO)
|
||
{
|
||
uCaps |= CAPFLAG_AUDIO_IN_USE;
|
||
}
|
||
if (dwFlags & PF_MEDIA_DATA)
|
||
{
|
||
uCaps |= CAPFLAG_DATA_IN_USE;
|
||
}
|
||
if (dwFlags & PF_H323)
|
||
{
|
||
uCaps |= CAPFLAG_H323_IN_USE;
|
||
}
|
||
}
|
||
|
||
if (!m_fAllowAV)
|
||
{
|
||
uCaps &= ~(CAPFLAGS_AV_ALL);
|
||
}
|
||
|
||
return uCaps;
|
||
}
|
||
|
||
|
||
ULONG COprahNCUI::GetAuthenticatedName(PBYTE * ppb)
|
||
{
|
||
// Buffer created here should be freed by caller.
|
||
|
||
ULONG cb;
|
||
|
||
if (::T120_GetSecurityInfoFromGCCID(0,NULL,&cb)) {
|
||
(*ppb) = new BYTE[cb];
|
||
if ((*ppb) != NULL) {
|
||
::T120_GetSecurityInfoFromGCCID(0,*ppb,&cb);
|
||
return cb;
|
||
}
|
||
}
|
||
(* ppb) = NULL;
|
||
return 0;
|
||
|
||
}
|
||
|
||
HRESULT COprahNCUI::OnUpdateUserData(CONF_HANDLE hConference)
|
||
{
|
||
CRosterInfo ri;
|
||
|
||
// This string will contain addresses in the form:
|
||
// L"TCP:157.55.143.3\0TCP:157.55.143.4\0\0" - 512 character max for now
|
||
WCHAR wszAddresses[512];
|
||
ASSERT(g_pNodeController);
|
||
ASSERT(hConference);
|
||
if (NOERROR == hConference->GetLocalAddressList(wszAddresses,
|
||
CCHMAX(wszAddresses)))
|
||
{
|
||
ri.Load(wszAddresses);
|
||
}
|
||
|
||
// First, handle roster information
|
||
GetRosterInfo(&ri);
|
||
|
||
PVOID pvData;
|
||
UINT cbDataLen;
|
||
if (SUCCEEDED(ri.Save(&pvData, &cbDataLen)))
|
||
{
|
||
ASSERT(g_pNodeController);
|
||
ASSERT(hConference);
|
||
hConference->SetUserData(&g_csguidRostInfo,
|
||
cbDataLen,
|
||
pvData);
|
||
}
|
||
|
||
// Next, handle caps information
|
||
ULONG uCaps = GetRosterCaps();
|
||
ASSERT(g_pNodeController);
|
||
ASSERT(hConference);
|
||
hConference->SetUserData(&g_csguidRosterCaps, sizeof(uCaps), &uCaps);
|
||
|
||
// Next, handle credentials
|
||
|
||
if ( hConference->IsSecure() )
|
||
{
|
||
BYTE * pb = NULL;
|
||
ULONG cb = GetAuthenticatedName(&pb);
|
||
if (cb > 0) {
|
||
ASSERT(g_pNodeController);
|
||
ASSERT(hConference);
|
||
TRACE_OUT(("COprahNCUI::OnUpdateUserData: adding %d bytes SECURITY data", cb));
|
||
hConference->SetUserData(&g_csguidSecurity, cb, pb);
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("OnUpdateUserData: 0 bytes security data?"));
|
||
}
|
||
delete [] pb;
|
||
}
|
||
|
||
// Next, set meeting settings if we hosted the meeting
|
||
ASSERT(m_pConfObject);
|
||
if (m_pConfObject->IsHosting() == S_OK)
|
||
{
|
||
NM30_MTG_PERMISSIONS attendeePermissions = m_pConfObject->GetConfAttendeePermissions();
|
||
|
||
WARNING_OUT(("Hosted Meeting Settings 0x%08lx", attendeePermissions));
|
||
|
||
hConference->SetUserData(&g_csguidMeetingSettings,
|
||
sizeof(attendeePermissions), &attendeePermissions);
|
||
}
|
||
|
||
ULONG nRecords;
|
||
GCCUserData ** ppUserData = NULL;
|
||
if (m_pSysInfo)
|
||
{
|
||
m_pSysInfo->GetUserDataList(&nRecords,&ppUserData);
|
||
for (unsigned int i = 0; i < nRecords; i++) {
|
||
// Do not add user data that was already set above.
|
||
if (memcmp(ppUserData[i]->octet_string->value,(PVOID)&g_csguidRostInfo,sizeof(GUID)) == 0)
|
||
continue;
|
||
if (memcmp(ppUserData[i]->octet_string->value,(PVOID)&g_csguidRosterCaps,sizeof(GUID)) == 0)
|
||
continue;
|
||
if (memcmp(ppUserData[i]->octet_string->value,(PVOID)&g_csguidSecurity,sizeof(GUID)) == 0)
|
||
continue;
|
||
if (memcmp(ppUserData[i]->octet_string->value,(PVOID)&g_csguidMeetingSettings,sizeof(GUID)) == 0)
|
||
continue;
|
||
|
||
ASSERT(g_pNodeController);
|
||
ASSERT(hConference);
|
||
hConference->SetUserData((GUID *)(ppUserData[i]->octet_string->value),
|
||
ppUserData[i]->octet_string->length - sizeof(GUID), ppUserData[i]->octet_string->value + sizeof(GUID));
|
||
}
|
||
}
|
||
|
||
// only add the LocalNodeId to the roster if H323 is enabled
|
||
if (IsH323Enabled())
|
||
{
|
||
hConference->SetUserData((GUID *)(&g_csguidNodeIdTag), sizeof(GUID), (PVOID)&g_guidLocalNodeId);
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT COprahNCUI::OnIncomingInviteRequest(CONF_HANDLE hConference,
|
||
PCWSTR pcwszNodeName,
|
||
PT120PRODUCTVERSION pRequestorVersion,
|
||
PUSERDATAINFO pUserDataInfoEntries,
|
||
UINT cUserDataEntries,
|
||
BOOL fSecure)
|
||
{
|
||
DebugEntry(COprahNCUI::OnIncomingInviteRequest);
|
||
|
||
// Fix an AV problem ONLY for RTC client
|
||
if (m_pConfObject == NULL)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
if (!m_pConfObject->OnT120Invite(hConference, fSecure))
|
||
{
|
||
// Respond negatively - already in a call
|
||
TRACE_OUT(("Rejecting invite - already in a call"));
|
||
ASSERT(g_pNodeController);
|
||
ASSERT(hConference);
|
||
hConference->InviteResponse(FALSE);
|
||
}
|
||
else
|
||
{
|
||
m_pIncomingCallManager->OnIncomingT120Call( this,
|
||
TRUE,
|
||
hConference,
|
||
pcwszNodeName,
|
||
pUserDataInfoEntries,
|
||
cUserDataEntries,
|
||
fSecure);
|
||
|
||
//
|
||
// This will simply notify the UI about the call state.
|
||
//
|
||
m_pConfObject->SetConfSecurity(fSecure);
|
||
}
|
||
|
||
DebugExitHRESULT(COprahNCUI::OnIncomingInviteRequest, S_OK);
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
HRESULT COprahNCUI::OnIncomingJoinRequest( CONF_HANDLE hConference,
|
||
PCWSTR pcwszNodeName,
|
||
PT120PRODUCTVERSION pRequestorVersion,
|
||
PUSERDATAINFO pUserDataInfoEntries,
|
||
UINT cUserDataEntries)
|
||
{
|
||
DebugEntry(COprahNCUI::OnIncomingJoinRequest);
|
||
|
||
// shouldn't we be checking for an active conference before accepting a join
|
||
// or will T120 not present this
|
||
|
||
m_pIncomingCallManager->OnIncomingT120Call( this,
|
||
FALSE,
|
||
hConference,
|
||
pcwszNodeName,
|
||
pUserDataInfoEntries,
|
||
cUserDataEntries,
|
||
m_pConfObject->IsConfObjSecure());
|
||
|
||
DebugExitHRESULT(COprahNCUI::OnIncomingJoinRequest, S_OK);
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
HRESULT COprahNCUI::OnConferenceStarted(CONF_HANDLE hConference, HRESULT hResult)
|
||
{
|
||
DebugEntry(COprahNCUI::OnConferenceStarted);
|
||
|
||
if (m_pConfObject->GetConfHandle() == hConference)
|
||
{
|
||
m_pConfObject->OnConferenceStarted(hConference, hResult);
|
||
|
||
m_pOutgoingCallManager->OnConferenceStarted(hConference, hResult);
|
||
}
|
||
|
||
DebugExitHRESULT(COprahNCUI::OnConferenceStarted, S_OK);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT COprahNCUI::OnQueryRemoteResult(PVOID pvCallerContext,
|
||
HRESULT hResult,
|
||
BOOL fMCU,
|
||
PWSTR* ppwszConferenceNames,
|
||
PT120PRODUCTVERSION pVersion,
|
||
PWSTR* ppwszConfDescriptors)
|
||
{
|
||
DebugEntry(COprahNCUI::OnQueryRemoteResult);
|
||
|
||
if (NO_ERROR == hResult)
|
||
{
|
||
TRACE_OUT(("COprahNCUI: OnQueryRemoteResult Success!"));
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("COprahNCUI: OnQueryRemoteResult Failure!"));
|
||
}
|
||
|
||
m_pOutgoingCallManager->OnQueryRemoteResult(pvCallerContext,
|
||
hResult,
|
||
fMCU,
|
||
ppwszConferenceNames,
|
||
pVersion,
|
||
ppwszConfDescriptors);
|
||
|
||
DebugExitHRESULT(COprahNCUI::OnQueryRemoteResult, S_OK);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT COprahNCUI::OnInviteResult( CONF_HANDLE hConference,
|
||
REQUEST_HANDLE hRequest,
|
||
UINT uNodeID,
|
||
HRESULT hResult,
|
||
PT120PRODUCTVERSION pVersion)
|
||
{
|
||
DebugEntry(COprahNCUI::OnInviteResult);
|
||
|
||
if (hConference == m_pConfObject->GetConfHandle())
|
||
{
|
||
m_pOutgoingCallManager->OnInviteResult( hConference,
|
||
hRequest,
|
||
uNodeID,
|
||
hResult,
|
||
pVersion);
|
||
}
|
||
|
||
DebugExitHRESULT(COprahNCUI::OnInviteResult, S_OK);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT COprahNCUI::OnConferenceEnded(CONF_HANDLE hConference)
|
||
{
|
||
DebugEntry(COprahNCUI::OnConferenceEnded);
|
||
|
||
if (m_pConfObject && (hConference == m_pConfObject->GetConfHandle()))
|
||
{
|
||
m_pConfObject->OnConferenceEnded();
|
||
|
||
m_pOutgoingCallManager->OnConferenceEnded(hConference);
|
||
|
||
m_pIncomingCallManager->OnT120ConferenceEnded(hConference);
|
||
}
|
||
|
||
DebugExitHRESULT(COprahNCUI::OnConferenceEnded, S_OK);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT COprahNCUI::OnRosterChanged(CONF_HANDLE hConf, PNC_ROSTER pRoster)
|
||
{
|
||
TRACE_OUT(("COprahNCUI::OnRosterChanged"));
|
||
|
||
if (hConf == m_pConfObject->GetConfHandle())
|
||
{
|
||
m_pConfObject->OnRosterChanged(pRoster);
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
ULONG STDMETHODCALLTYPE COprahNCUI::AddRef(void)
|
||
{
|
||
return RefCount::AddRef();
|
||
}
|
||
|
||
ULONG STDMETHODCALLTYPE COprahNCUI::Release(void)
|
||
{
|
||
return RefCount::Release();
|
||
}
|
||
|
||
HRESULT STDMETHODCALLTYPE COprahNCUI::QueryInterface(REFIID riid, PVOID *ppv)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
if ((riid == IID_INmManager2) || (riid == IID_INmManager) || (riid == IID_IUnknown))
|
||
{
|
||
*ppv = (INmManager2 *)this;
|
||
ApiDebugMsg(("COprahNCUI::QueryInterface()"));
|
||
}
|
||
else if (riid == IID_IConnectionPointContainer)
|
||
{
|
||
*ppv = (IConnectionPointContainer *) this;
|
||
ApiDebugMsg(("COprahNCUI::QueryInterface(): Returning IConnectionPointContainer."));
|
||
}
|
||
else
|
||
{
|
||
hr = E_NOINTERFACE;
|
||
*ppv = NULL;
|
||
ApiDebugMsg(("COprahNCUI::QueryInterface(): Called on unknown interface."));
|
||
}
|
||
|
||
if (S_OK == hr)
|
||
{
|
||
AddRef();
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
/* I N I T I A L I Z E */
|
||
/*-------------------------------------------------------------------------
|
||
%%Function: Initialize
|
||
|
||
REVIEW: What should the return value be if any of these parts fail
|
||
to initialize or load?
|
||
-------------------------------------------------------------------------*/
|
||
HRESULT COprahNCUI::Initialize(ULONG *puOptions, ULONG *puchCaps)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
// puOptions is UNUSED
|
||
|
||
ASSERT(puchCaps);
|
||
|
||
m_pOutgoingCallManager = new COutgoingCallManager;
|
||
if (!m_pOutgoingCallManager)
|
||
{
|
||
ERROR_OUT(("COprahNCUI::Initialize -- failed to create outgoing call mgr"));
|
||
return(E_OUTOFMEMORY);
|
||
}
|
||
|
||
m_pIncomingCallManager = new CIncomingCallManager;
|
||
if (!m_pIncomingCallManager)
|
||
{
|
||
ERROR_OUT(("COprahNCUI::Initialize -- failed to create incoming call mgr"));
|
||
return(E_OUTOFMEMORY);
|
||
}
|
||
|
||
// The lifetime of this object is up to the reference counting crap
|
||
m_pConfObject = new CConfObject;
|
||
if (!m_pConfObject)
|
||
{
|
||
ERROR_OUT(("COprahNCUI::Initialize -- failed to create conf object"));
|
||
return(E_OUTOFMEMORY);
|
||
}
|
||
|
||
m_pConfObject->Init(this);
|
||
|
||
WNDCLASS wcHidden =
|
||
{
|
||
0L,
|
||
COprahNCUI::WndProc,
|
||
0,
|
||
0,
|
||
GetInstanceHandle(),
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
cszDllHiddenWndClassName
|
||
};
|
||
|
||
if (!RegisterClass(&wcHidden))
|
||
{
|
||
ERROR_OUT(("COprahNCUI::Initialize -- failed to register HiddenWnd class"));
|
||
return(E_OUTOFMEMORY);
|
||
}
|
||
|
||
// Create a hidden window for event processing:
|
||
m_hwnd = ::CreateWindow(cszDllHiddenWndClassName,
|
||
_TEXT(""),
|
||
WS_POPUP, // not visible!
|
||
0, 0, 0, 0,
|
||
NULL,
|
||
NULL,
|
||
GetInstanceHandle(),
|
||
NULL);
|
||
|
||
if (NULL == m_hwnd)
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
//
|
||
// INIT QOS only if AV is in the picture (otherwise, there's nothing
|
||
// to arbitrate).
|
||
//
|
||
if (CAPFLAGS_AV_STREAMS & *puchCaps)
|
||
{
|
||
m_pQoS = new CQoS();
|
||
if (NULL != m_pQoS)
|
||
{
|
||
hr = m_pQoS->Initialize();
|
||
if (FAILED(hr))
|
||
{
|
||
WARNING_OUT(("CQoS::Init() failed!"));
|
||
|
||
// let NetMeeting hobble along without QoS.
|
||
delete m_pQoS;
|
||
m_pQoS = NULL;
|
||
hr = S_FALSE; // we can live without QOS
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("Could not allocate CQoS object"));
|
||
}
|
||
}
|
||
|
||
//
|
||
// IF DATA CONFERENCING IS ALLOWED
|
||
//
|
||
if (CAPFLAG_DATA & *puchCaps)
|
||
{
|
||
//
|
||
// Create the node controller
|
||
//
|
||
hr = ::T120_CreateNodeController(&g_pNodeController, this);
|
||
if (FAILED(hr))
|
||
{
|
||
ERROR_OUT(("T120_CreateNodeController() failed!"));
|
||
return hr;
|
||
}
|
||
}
|
||
|
||
// Initialize audio/video
|
||
if (CAPFLAGS_AV_ALL & *puchCaps)
|
||
{
|
||
g_pH323UI = new CH323UI();
|
||
if (NULL != g_pH323UI)
|
||
{
|
||
hr = g_pH323UI->Init(m_hwnd, ::GetInstanceHandle(), *puchCaps, this, this);
|
||
if (FAILED(hr))
|
||
{
|
||
WARNING_OUT(("CH323UI::Init() failed!"));
|
||
delete g_pH323UI;
|
||
g_pH323UI = NULL;
|
||
*puchCaps &= ~(CAPFLAGS_AV_ALL);
|
||
hr = S_FALSE; // We can run without AV
|
||
}
|
||
else
|
||
{
|
||
if (CAPFLAGS_VIDEO & *puchCaps)
|
||
{
|
||
// if we can get a Preview channel, we can send video
|
||
m_pPreviewChannel = CNmChannelVideo::CreatePreviewChannel();
|
||
if (NULL == m_pPreviewChannel)
|
||
{
|
||
*puchCaps &= ~CAPFLAG_SEND_VIDEO;
|
||
}
|
||
}
|
||
|
||
if (m_pConfObject && (CAPFLAGS_AV_STREAMS & *puchCaps))
|
||
{
|
||
IMediaChannelBuilder *pStreamProvider;
|
||
|
||
pStreamProvider = g_pH323UI->GetStreamProvider();
|
||
if (pStreamProvider)
|
||
{
|
||
pStreamProvider->SetStreamEventObj(m_pConfObject);
|
||
pStreamProvider->Release();
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("Could not allocate CH323UI object"));
|
||
}
|
||
}
|
||
|
||
m_uCaps = *puchCaps;
|
||
|
||
return CoCreateGuid(&g_guidLocalNodeId);
|
||
}
|
||
|
||
|
||
|
||
HRESULT COprahNCUI::GetSysInfo(INmSysInfo **ppSysInfo)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
if( ppSysInfo )
|
||
{
|
||
if(m_pSysInfo )
|
||
{
|
||
m_pSysInfo->AddRef();
|
||
*ppSysInfo = m_pSysInfo;
|
||
}
|
||
else
|
||
{
|
||
hr = E_OUTOFMEMORY;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
hr = E_POINTER;
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
HRESULT COprahNCUI::EnumConference(IEnumNmConference **ppEnum)
|
||
{
|
||
return E_NOTIMPL;
|
||
}
|
||
|
||
HRESULT COprahNCUI::CreateConference( INmConference **ppConference,
|
||
BSTR bstrName,
|
||
BSTR bstrPassword,
|
||
ULONG uchCaps)
|
||
{
|
||
return(CreateConferenceEx(ppConference, bstrName, bstrPassword,
|
||
uchCaps, NM_PERMIT_ALL, (UINT)-1));
|
||
}
|
||
|
||
|
||
HRESULT COprahNCUI::EnumCall(IEnumNmCall **ppEnum)
|
||
{
|
||
return E_NOTIMPL;
|
||
}
|
||
|
||
HRESULT COprahNCUI::CreateCall(
|
||
INmCall **ppCall,
|
||
NM_CALL_TYPE callType,
|
||
NM_ADDR_TYPE addrType,
|
||
BSTR bstrAddress,
|
||
INmConference * pConference)
|
||
{
|
||
return E_NOTIMPL;
|
||
}
|
||
|
||
HRESULT COprahNCUI::CallConference(
|
||
INmCall **ppCall,
|
||
NM_CALL_TYPE callType,
|
||
NM_ADDR_TYPE addrType,
|
||
BSTR bstrAddress,
|
||
BSTR bstrConfToJoin,
|
||
BSTR bstrPassword)
|
||
{
|
||
return E_NOTIMPL;
|
||
}
|
||
|
||
STDMETHODIMP COprahNCUI::GetPreviewChannel(INmChannelVideo **ppChannelVideo)
|
||
{
|
||
HRESULT hr = E_POINTER;
|
||
if (NULL != ppChannelVideo)
|
||
{
|
||
*ppChannelVideo = m_pPreviewChannel;
|
||
if (NULL != m_pPreviewChannel)
|
||
{
|
||
m_pPreviewChannel->AddRef();
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
{
|
||
hr = E_FAIL;
|
||
}
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
|
||
STDMETHODIMP COprahNCUI::CreateASObject
|
||
(
|
||
IUnknown * pNotify,
|
||
ULONG flags,
|
||
IUnknown ** ppAS
|
||
)
|
||
{
|
||
return(::CreateASObject((IAppSharingNotify *)pNotify, flags,
|
||
(IAppSharing **)ppAS));
|
||
}
|
||
|
||
|
||
HRESULT COprahNCUI::CallEx(
|
||
INmCall **ppCall,
|
||
DWORD dwFlags,
|
||
NM_ADDR_TYPE addrType,
|
||
BSTR bstrName,
|
||
BSTR bstrSetup,
|
||
BSTR bstrDest,
|
||
BSTR bstrAlias,
|
||
BSTR bstrURL,
|
||
BSTR bstrConference,
|
||
BSTR bstrPassword,
|
||
BSTR bstrUserData)
|
||
{
|
||
DebugEntry(COprahNCUI::CallEx);
|
||
|
||
HRESULT hr = m_pOutgoingCallManager->Call( ppCall,
|
||
this,
|
||
dwFlags,
|
||
addrType,
|
||
bstrName,
|
||
bstrSetup,
|
||
bstrDest,
|
||
bstrAlias,
|
||
bstrURL,
|
||
bstrConference,
|
||
bstrPassword,
|
||
bstrUserData);
|
||
|
||
DebugExitHRESULT(COprahNCUI::CallEx, hr);
|
||
return hr;
|
||
}
|
||
|
||
|
||
HRESULT COprahNCUI::CreateConferenceEx
|
||
(
|
||
INmConference **ppConference,
|
||
BSTR bstrName,
|
||
BSTR bstrPassword,
|
||
DWORD uchCaps,
|
||
DWORD attendeePermissions,
|
||
DWORD maxParticipants
|
||
)
|
||
{
|
||
if (NULL == ppConference)
|
||
{
|
||
ERROR_OUT(("CreateConferenceEx: null ppConference passed in"));
|
||
return E_POINTER;
|
||
}
|
||
|
||
if (maxParticipants < 2)
|
||
{
|
||
ERROR_OUT(("CreateConferenceEx: bad maxParticipants %d", maxParticipants));
|
||
return E_INVALIDARG;
|
||
}
|
||
|
||
if (m_pConfObject->IsConferenceActive())
|
||
{
|
||
WARNING_OUT(("CreateConference is failing because IsConferenceActive return TRUE"));
|
||
return NM_CALLERR_IN_CONFERENCE;
|
||
}
|
||
|
||
m_pConfObject->SetConfName(bstrName);
|
||
if (uchCaps & NMCH_SRVC)
|
||
m_pConfObject->SetConfHashedPassword(bstrPassword);
|
||
else
|
||
m_pConfObject->SetConfPassword(bstrPassword);
|
||
|
||
|
||
if (uchCaps & NMCH_SECURE)
|
||
m_pConfObject->SetConfSecurity(TRUE);
|
||
else
|
||
m_pConfObject->SetConfSecurity(FALSE);
|
||
|
||
|
||
m_pConfObject->SetConfAttendeePermissions(attendeePermissions);
|
||
m_pConfObject->SetConfMaxParticipants(maxParticipants);
|
||
|
||
if (!m_pConfObject->IsConferenceCreated())
|
||
{
|
||
m_pConfObject->OnConferenceCreated();
|
||
}
|
||
|
||
NotifySink((INmConference*) m_pConfObject, OnNotifyConferenceCreated);
|
||
|
||
|
||
*ppConference = m_pConfObject;
|
||
if(*ppConference)
|
||
{
|
||
(*ppConference)->AddRef();
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
/* O N N O T I F Y C O N F E R E N C E C R E A T E D */
|
||
/*-------------------------------------------------------------------------
|
||
%%Function: OnNotifyConferenceCreated
|
||
|
||
-------------------------------------------------------------------------*/
|
||
HRESULT OnNotifyConferenceCreated(IUnknown *pManagerNotify, PVOID pv, REFIID riid)
|
||
{
|
||
ASSERT(NULL != pManagerNotify);
|
||
((INmManagerNotify*)pManagerNotify)->ConferenceCreated((INmConference *) pv);
|
||
return S_OK;
|
||
}
|
||
|
||
/* O N N O T I F Y C A L L C R E A T E D */
|
||
/*-------------------------------------------------------------------------
|
||
%%Function: OnNotifyCallCreated
|
||
|
||
-------------------------------------------------------------------------*/
|
||
HRESULT OnNotifyCallCreated(IUnknown *pManagerNotify, PVOID pv, REFIID riid)
|
||
{
|
||
ASSERT(NULL != pManagerNotify);
|
||
((INmManagerNotify*)pManagerNotify)->CallCreated((INmCall *) pv);
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
/* O N N O T I F Y C A L L S T A T E C H A N G E D */
|
||
/*-------------------------------------------------------------------------
|
||
%%Function: OnNotifyCallStateChanged
|
||
|
||
-------------------------------------------------------------------------*/
|
||
HRESULT OnNotifyCallStateChanged(IUnknown *pCallNotify, PVOID pv, REFIID riid)
|
||
{
|
||
ASSERT(NULL != pCallNotify);
|
||
((INmCallNotify*)pCallNotify)->StateChanged((NM_CALL_STATE)(DWORD_PTR)pv);
|
||
return S_OK;
|
||
}
|
||
|
||
VOID SetBandwidth(UINT uBandwidth)
|
||
{
|
||
COprahNCUI *pOprahNCUI = COprahNCUI::GetInstance();
|
||
if (NULL != pOprahNCUI)
|
||
{
|
||
pOprahNCUI->SetBandwidth(uBandwidth);
|
||
}
|
||
if (NULL != g_pH323UI)
|
||
{
|
||
//Inform the NAC of the connection speed
|
||
g_pH323UI->SetBandwidth(uBandwidth);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// BOGUS LAURABU!
|
||
// Do we need this HWND anymore? The hidden window is used now only to
|
||
// pass to H323, which passes it to the MediaStream interfaces in the NAC,
|
||
// which passes it to DirectX.
|
||
//
|
||
|
||
LRESULT CALLBACK COprahNCUI::WndProc(HWND hwnd, UINT uMsg,
|
||
WPARAM wParam, LPARAM lParam)
|
||
{
|
||
|
||
// if ms_msgChannelEvent is 0, that means that we are not initialized
|
||
// RegisterWindowMessage returns MSGIds in the range 0xC000 through 0xFFFF
|
||
if(CH323ChannelEvent::ms_msgChannelEvent && CH323ChannelEvent::ms_msgChannelEvent == uMsg)
|
||
{
|
||
COprahNCUI *pOprahNCUI = COprahNCUI::GetInstance();
|
||
if (pOprahNCUI)
|
||
{
|
||
CH323ChannelEvent *pEvent = reinterpret_cast<CH323ChannelEvent*>(lParam);
|
||
if(pEvent)
|
||
{
|
||
// if we're shutting down m_hwnd will be NULL
|
||
if (pOprahNCUI->m_hwnd)
|
||
{
|
||
pOprahNCUI->_ChannelEvent(
|
||
pEvent->GetChannel(),
|
||
pEvent->GetEndpoint(),
|
||
pEvent->GetStatus());
|
||
}
|
||
delete pEvent;
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("Why are we getting a NULL pEvent?"));
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
||
}
|
||
|
||
PIUnknown NewNmManager(OBJECTDESTROYEDPROC ObjectDestroyed)
|
||
{
|
||
COprahNCUI *pManager = new COprahNCUI(ObjectDestroyed);
|
||
if (NULL != pManager)
|
||
{
|
||
return (INmManager2 *) pManager;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
VOID COprahNCUI::_ChannelEvent (ICommChannel *pIChannel,
|
||
IH323Endpoint * lpConnection, DWORD dwStatus )
|
||
{
|
||
ASSERT(pIChannel);
|
||
GUID guidMedia;
|
||
if (SUCCEEDED(pIChannel->GetMediaType(&guidMedia)))
|
||
{
|
||
if (MEDIA_TYPE_H323AUDIO == guidMedia)
|
||
{
|
||
OnAudioChannelStatus(pIChannel, lpConnection, dwStatus);
|
||
}
|
||
else if (MEDIA_TYPE_H323VIDEO == guidMedia)
|
||
{
|
||
OnVideoChannelStatus(pIChannel, lpConnection, dwStatus);
|
||
}
|
||
else if (MEDIA_TYPE_H323_T120 == guidMedia)
|
||
{
|
||
switch (dwStatus)
|
||
{
|
||
case CHANNEL_OPEN_ERROR:
|
||
case CHANNEL_OPEN:
|
||
case CHANNEL_CLOSED:
|
||
case CHANNEL_REJECTED:
|
||
case CHANNEL_NO_CAPABILITY:
|
||
OnT120ChannelOpen(pIChannel, lpConnection, dwStatus);
|
||
break;
|
||
|
||
default:
|
||
WARNING_OUT(("COprahNCUI::ChannelEvent - unrecognized T120 status"));
|
||
break;
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("COprahNCUI::ChannelEvent - unknown media type"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("COprahNCUI::ChannelEvent - pIChannel->GetMediaType() failed"));
|
||
}
|
||
}
|
||
|
||
STDMETHODIMP COprahNCUI::ChannelEvent (ICommChannel *pIChannel,
|
||
IH323Endpoint * lpConnection, DWORD dwStatus )
|
||
{
|
||
ASSERT(pIChannel);
|
||
GUID guidMedia;
|
||
if (SUCCEEDED(pIChannel->GetMediaType(&guidMedia)))
|
||
{
|
||
if (MEDIA_TYPE_H323_T120 == guidMedia)
|
||
{
|
||
if (NULL != m_hwnd)
|
||
{
|
||
CH323ChannelEvent* pEvent = new CH323ChannelEvent(
|
||
pIChannel,
|
||
lpConnection,
|
||
dwStatus);
|
||
if (pEvent)
|
||
{
|
||
PostMessage(m_hwnd,
|
||
CH323ChannelEvent::ms_msgChannelEvent,
|
||
0,
|
||
reinterpret_cast<LPARAM>(pEvent));
|
||
return S_OK;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_ChannelEvent(pIChannel, lpConnection, dwStatus);
|
||
return S_OK;
|
||
}
|
||
}
|
||
|
||
return E_FAIL;
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
VOID TraceStatus(DWORD dwStatus)
|
||
{
|
||
switch(dwStatus)
|
||
{
|
||
case CONNECTION_DISCONNECTED:
|
||
TRACE_OUT(("COprahNCUI::CallEvent: CONNECTION_DISCONNECTED"));
|
||
break;
|
||
|
||
case CONNECTION_CONNECTED:
|
||
TRACE_OUT(("COprahNCUI::CallEvent: CONNECTION_CONNECTED"));
|
||
break;
|
||
|
||
case CONNECTION_RECEIVED_DISCONNECT:
|
||
TRACE_OUT(( "COprahNCUI::CallEvent: RECEIVED_DISCONNECT"));
|
||
break;
|
||
|
||
case CONNECTION_PROCEEDING:
|
||
TRACE_OUT(("COprahNCUI::CallEvent: CONNECTION_PROCEEDING"));
|
||
break;
|
||
|
||
case CONNECTION_REJECTED:
|
||
TRACE_OUT(("COprahNCUI::CallEvent: CONNECTION_REJECTED"));
|
||
break;
|
||
|
||
default:
|
||
TRACE_OUT(("COprahNCUI::CallEvent: dwStatus = %d", dwStatus));
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
STDMETHODIMP COprahNCUI::CallEvent(IH323Endpoint * lpConnection, DWORD dwStatus)
|
||
{
|
||
|
||
DebugEntry(COprahNCUI::CallEvent);
|
||
IH323CallControl * pH323CallControl = g_pH323UI->GetH323CallControl();
|
||
#ifdef DEBUG
|
||
TraceStatus(dwStatus);
|
||
#endif
|
||
|
||
switch (dwStatus)
|
||
{
|
||
case CONNECTION_DISCONNECTED:
|
||
OnH323Disconnected(lpConnection);
|
||
break;
|
||
|
||
case CONNECTION_CONNECTED:
|
||
// This is currently interpreted as CONNECTION_CAPABILITIES_READY.
|
||
// Lower layers are continuing to post CONNECTION_CONNECTED only after
|
||
// capabilities are exchanged. note that channels may be opened while
|
||
// inside OnH323Connected();
|
||
OnH323Connected(lpConnection);
|
||
break;
|
||
}
|
||
|
||
DebugExitVOID(COprahNCUI::CallEvent);
|
||
return S_OK;
|
||
}
|
||
|
||
STDMETHODIMP COprahNCUI::GetMediaChannel (GUID *pmediaID,
|
||
BOOL bSendDirection, IMediaChannel **ppI)
|
||
{
|
||
// delegate to the appropriate stream provider. For the time being
|
||
// there is only one provider that does both audio & video
|
||
return g_pH323UI->GetMediaChannel (pmediaID, bSendDirection, ppI);
|
||
}
|
||
|
||
|
||
|