1026 lines
33 KiB
C++
1026 lines
33 KiB
C++
/*++
|
|
|
|
Copyright (c) 1997-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Call.h
|
|
|
|
Abstract:
|
|
|
|
Declaration of the CAgentSession & CCall class
|
|
|
|
Author:
|
|
|
|
mquinton 06-12-97
|
|
|
|
Notes:
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#ifndef __CALL_H_
|
|
#define __CALL_H_
|
|
|
|
#include "resource.h" // main symbols
|
|
#include "address.h"
|
|
|
|
#ifdef USE_PHONEMSP
|
|
#include "terminal.h"
|
|
#endif USE_PHONEMSP
|
|
|
|
#include "callhub.h"
|
|
#include "callevnt.h"
|
|
|
|
|
|
extern CHashTable * gpCallHashTable;
|
|
extern CHashTable * gpHandleHashTable;
|
|
extern void RemoveHandleFromHashTable(ULONG_PTR Handle);
|
|
|
|
|
|
//
|
|
// helper function for converting array of bytes to a byte array. the caller
|
|
// must ClientFree *ppBuffer when done.
|
|
//
|
|
|
|
HRESULT
|
|
MakeBufferFromVariant(
|
|
IN VARIANT var,
|
|
OUT DWORD * pdwSize,
|
|
OUT BYTE ** ppBuffer
|
|
);
|
|
|
|
typedef enum
|
|
{
|
|
STREAM_RENDERAUDIO = 0,
|
|
STREAM_RENDERVIDEO,
|
|
STREAM_CAPTUREAUDIO,
|
|
STREAM_CAPTUREVIDEO,
|
|
STREAM_NONE
|
|
} CALL_STREAMS;
|
|
|
|
|
|
HRESULT
|
|
WINAPI
|
|
MyBasicCallControlQI(void* pv, REFIID riid, LPVOID* ppv, DWORD_PTR dw);
|
|
|
|
// the app needs to be notified of this call
|
|
#define CALLFLAG_NEEDTONOTIFY 0x00000001
|
|
|
|
// the call is an incoming call
|
|
#define CALLFLAG_INCOMING 0x00000002
|
|
|
|
// A Consultation Call
|
|
#define CALLFLAG_CONSULTCALL 0x00000008
|
|
|
|
// A Consultation Call used in a transfer
|
|
#define CALLFLAG_TRANSFCONSULT 0x00000010
|
|
|
|
// A Consultation Call used in a conference
|
|
#define CALLFLAG_CONFCONSULT 0x00000020
|
|
|
|
// received line_callinfo message
|
|
#define CALLFLAG_CALLINFODIRTY 0x00000040
|
|
|
|
// Don't send the app any notifications about this call
|
|
#define CALLFLAG_DONTEXPOSE 0x00000100
|
|
|
|
// don't close m_addresslinestruct
|
|
#define CALLFLAG_NOTMYLINE 0x00000200
|
|
|
|
// Need to do a line accept before transitioning to CS_OFFERING
|
|
#define CALLFLAG_ACCEPTTOALERT 0x00000400
|
|
|
|
#define ISHOULDUSECALLPARAMS() ( ( NULL != m_pCallParams ) && ( CS_IDLE == m_CallState ) )
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Intermediate classes used for DISPID encoding
|
|
template <class T>
|
|
class ITCallInfoVtbl : public ITCallInfo
|
|
{
|
|
};
|
|
|
|
template <class T>
|
|
class ITCallInfo2Vtbl : public ITCallInfo2
|
|
{
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class ITBasicCallControlVtbl : public ITBasicCallControl
|
|
{
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class ITLegacyCallMediaControl2Vtbl : public ITLegacyCallMediaControl2
|
|
{
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class ITBasicCallControl2Vtbl : public ITBasicCallControl2
|
|
{
|
|
};
|
|
|
|
|
|
class CAddress;
|
|
class CCallHub;
|
|
class CCallStateEvent;
|
|
class CCallNotificationEvent;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCall
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
class CCall :
|
|
public CTAPIComObjectRoot<CCall>,
|
|
public IDispatchImpl<ITCallInfo2Vtbl<CCall>, &IID_ITCallInfo2, &LIBID_TAPI3Lib>,
|
|
public IDispatchImpl<ITBasicCallControl2Vtbl<CCall>, &IID_ITBasicCallControl2, &LIBID_TAPI3Lib>,
|
|
public IDispatchImpl<ITLegacyCallMediaControl2Vtbl<CCall>, &IID_ITLegacyCallMediaControl2, &LIBID_TAPI3Lib>,
|
|
public CObjectSafeImpl
|
|
{
|
|
|
|
public:
|
|
|
|
CCall() : m_pMSPCall(NULL),
|
|
m_CallState(CS_IDLE),
|
|
m_pAddressLine(NULL),
|
|
m_dwCallFlags(CALLFLAG_CALLINFODIRTY),
|
|
m_dwMediaMode(0),
|
|
m_pPrivate(NULL),
|
|
m_pCallHub(NULL),
|
|
m_pCallInfo(NULL),
|
|
m_pCallParams(NULL),
|
|
m_hConnectedEvent(NULL),
|
|
m_szDestAddress(NULL),
|
|
m_dwCountryCode(0),
|
|
m_bReleased(FALSE),
|
|
m_dwMinRate(0),
|
|
m_dwMaxRate(0),
|
|
m_pRelatedCall(NULL)
|
|
|
|
{
|
|
LOG((TL_TRACE, "CCall[%p] - enter", this));
|
|
LOG((TL_TRACE, "CCall - exit"));
|
|
}
|
|
|
|
~CCall()
|
|
{
|
|
LOG((TL_TRACE, "~CCall[%p] - enter", this));
|
|
LOG((TL_TRACE, "~CCall - exit"));
|
|
}
|
|
|
|
DECLARE_DEBUG_ADDREF_RELEASE(CCall)
|
|
DECLARE_QI()
|
|
DECLARE_MARSHALQI(CCall)
|
|
DECLARE_TRACELOG_CLASS(CCall)
|
|
|
|
BEGIN_COM_MAP(CCall)
|
|
COM_INTERFACE_ENTRY2(IDispatch, ITCallInfo2)
|
|
COM_INTERFACE_ENTRY(ITCallInfo)
|
|
COM_INTERFACE_ENTRY(ITCallInfo2)
|
|
COM_INTERFACE_ENTRY_FUNC(IID_ITBasicCallControl, 0, MyBasicCallControlQI)
|
|
COM_INTERFACE_ENTRY(ITBasicCallControl)
|
|
COM_INTERFACE_ENTRY_FUNC(IID_ITBasicCallControl2, 0, MyBasicCallControlQI)
|
|
COM_INTERFACE_ENTRY(ITBasicCallControl2)
|
|
COM_INTERFACE_ENTRY(ITLegacyCallMediaControl)
|
|
COM_INTERFACE_ENTRY(ITLegacyCallMediaControl2)
|
|
COM_INTERFACE_ENTRY(IObjectSafety)
|
|
COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
|
|
COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
|
|
COM_INTERFACE_ENTRY_AGGREGATE_BLIND(m_pMSPCall)
|
|
COM_INTERFACE_ENTRY_AGGREGATE_BLIND(m_pPrivate)
|
|
END_COM_MAP()
|
|
|
|
//
|
|
// check the aggregated objects to see if they support the interface requested.
|
|
// if they do, return the non-delegating IUnknown of the first object that
|
|
// supports the interface.
|
|
//
|
|
// it needs to be released by the caller.
|
|
//
|
|
|
|
HRESULT QIOnAggregates(REFIID riid, IUnknown **ppNonDelegatingUnknown);
|
|
|
|
void FinalRelease(){}
|
|
BOOL ExternalFinalRelease();
|
|
|
|
//
|
|
// public access functions to call object
|
|
// these are used by the address and callhub objects
|
|
// mostly to access stuff in the call
|
|
//
|
|
HRESULT Initialize(
|
|
CAddress * pAddress,
|
|
BSTR lpszDestAddress,
|
|
long lAddressType,
|
|
long lMediaType,
|
|
CALL_PRIVILEGE cp,
|
|
BOOL bNeedToNotify,
|
|
BOOL bExpose,
|
|
HCALL hCall,
|
|
CEventMasks* pEventMasks
|
|
);
|
|
HRESULT CallStateEvent( PASYNCEVENTMSG pParams );
|
|
HRESULT MediaModeEvent( PASYNCEVENTMSG pParam );
|
|
HRESULT GatherDigitsEvent( PASYNCEVENTMSG pParams );
|
|
HRESULT CallInfoChangeEvent( CALLINFOCHANGE_CAUSE cic );
|
|
HRESULT CreateMSPCall( long lMediaType );
|
|
HCALL GetHCall();
|
|
AddressLineStruct * GetPAddressLine();
|
|
BOOL DontExpose();
|
|
CCall * GetOtherParty();
|
|
void FinishSettingUpCall( HCALL hCall );
|
|
void SetCallHub( CCallHub * pCallHub );
|
|
void SetCallInfoDirty();
|
|
CAddress * GetCAddress();
|
|
ITStreamControl * GetStreamControl();
|
|
IUnknown * GetMSPCall();
|
|
CCallHub * GetCallHub();
|
|
|
|
//
|
|
// this function is called by the address object when it is notified of
|
|
// tapi object's shutdown. in this function, the call object gets a chance
|
|
// to clean up.
|
|
//
|
|
|
|
void CallOnTapiShutdown();
|
|
|
|
protected:
|
|
// IUnknown * m_pFTM;
|
|
|
|
private:
|
|
// owning address object
|
|
CAddress * m_pAddress;
|
|
// dest address
|
|
PWSTR m_szDestAddress;
|
|
// current call state
|
|
CALL_STATE m_CallState;
|
|
// current call priv
|
|
CALL_PRIVILEGE m_CallPrivilege;
|
|
// current mediamode
|
|
DWORD m_dwMediaMode;
|
|
// the MSP call
|
|
IUnknown * m_pMSPCall;
|
|
// Context handle passed to MSP Call
|
|
MSP_HANDLE m_MSPCallHandle;
|
|
// call flags ( see defines above )
|
|
DWORD m_dwCallFlags;
|
|
// this call's t3call
|
|
T3CALL m_t3Call;
|
|
// used in consult calls to ID the original call (needed to complete transf etc)
|
|
HCALL m_hAdditionalCall;
|
|
// related call
|
|
CCall * m_pRelatedCall;
|
|
// address line being used
|
|
AddressLineStruct * m_pAddressLine;
|
|
// private object
|
|
IUnknown * m_pPrivate;
|
|
// related call hub
|
|
CCallHub * m_pCallHub;
|
|
// cached callinfo structure
|
|
LINECALLINFO * m_pCallInfo;
|
|
// cached callparams structure
|
|
LINECALLPARAMS * m_pCallParams;
|
|
// used size of m_pcallparams
|
|
DWORD m_dwCallParamsUsedSize;
|
|
// if call is sync, need an event to signal
|
|
HANDLE m_hConnectedEvent;
|
|
// country code - the app can set this, but it's not part of callparams
|
|
DWORD m_dwCountryCode;
|
|
// protect against releasing twice
|
|
BOOL m_bReleased;
|
|
// Can't get these from TAPISRV so remember what gets set
|
|
DWORD m_dwMinRate;
|
|
DWORD m_dwMaxRate;
|
|
// queue for GatherDigits buffers
|
|
CTArray<LPWSTR> m_GatherDigitsQueue;
|
|
|
|
//
|
|
// private functions inside the call object.
|
|
//
|
|
void SetMediaMode( DWORD dwMediaMode );
|
|
void SetCallState( CALL_STATE cs );
|
|
void ResetCallParams();
|
|
void FinishCallParams();
|
|
void ClearConnectedEvent();
|
|
void SetRelatedCall(CCall* pCall, DWORD callFlags);
|
|
void ResetRelatedCall();
|
|
void AddCallToHashTable();
|
|
void RemoveCallFromHashTable();
|
|
|
|
|
|
//
|
|
// get an addreffed address line that corresponds to this address line
|
|
// handle
|
|
//
|
|
|
|
AddressLineStruct *GetAddRefAddressLine(DWORD dwAddressLineHandle);
|
|
|
|
|
|
public:
|
|
|
|
//
|
|
// get addreff'ed address line that belongs to this call.
|
|
//
|
|
|
|
AddressLineStruct *GetAddRefMyAddressLine();
|
|
|
|
|
|
//
|
|
// release address line received from GetAddRefAddressLine or GetAddRefMyAddressLine
|
|
//
|
|
|
|
HRESULT ReleaseAddressLine(AddressLineStruct *pLine);
|
|
|
|
|
|
public:
|
|
//
|
|
// get the callback instance associated with the address line represented
|
|
// by dwAddressLineHandle handle
|
|
//
|
|
|
|
HRESULT GetCallBackInstance(IN DWORD dwAddressLineHandle,
|
|
OUT long *plCallbackInstance);
|
|
|
|
|
|
public:
|
|
BOOL OnWaveMSPCall(); // called in event handler
|
|
private:
|
|
#ifdef USE_PHONEMSP
|
|
BOOL OnPhoneMSPCall();
|
|
#endif USE_PHONEMSP
|
|
CCall * FindConferenceControllerCall();
|
|
HANDLE CreateConnectedEvent();
|
|
|
|
HRESULT TryToFindACallHub();
|
|
HRESULT DialConsultCall(BOOL bSync);
|
|
HRESULT WaitForCallState( CALL_STATE requiredCS );
|
|
HRESULT CheckAndCreateFakeCallHub();
|
|
HRESULT UpdateStateAndPrivilege();
|
|
HRESULT OnConnect();
|
|
HRESULT OnDisconnect();
|
|
HRESULT OnConference();
|
|
HRESULT OnOffering();
|
|
HRESULT ProcessNewCallState(
|
|
DWORD dwCallState,
|
|
DWORD dwDetail,
|
|
CALL_STATE CurrentCallState,
|
|
CALL_STATE * pCallState,
|
|
CALL_STATE_EVENT_CAUSE * pCallStateCause
|
|
);
|
|
|
|
HRESULT RefreshCallInfo();
|
|
HRESULT ResizeCallParams( DWORD );
|
|
HRESULT SendUserUserInfo(HCALL hCall, long lSize, BYTE * pBuffer);
|
|
HRESULT SaveUserUserInfo(long lSize,BYTE * pBuffer);
|
|
HRESULT SyncWait( HANDLE hEvent );
|
|
HRESULT StartWaveMSPStream();
|
|
HRESULT StopWaveMSPStream();
|
|
HRESULT SuspendWaveMSPStream();
|
|
public:
|
|
HRESULT ResumeWaveMSPStream(); // called in event handler
|
|
private:
|
|
#ifdef USE_PHONEMSP
|
|
HRESULT StartPhoneMSPStream();
|
|
HRESULT StopPhoneMSPStream();
|
|
#endif USE_PHONEMSP
|
|
HRESULT DialAsConsultationCall(
|
|
CCall * pRelatedCall,
|
|
DWORD dwCallFeatures,
|
|
BOOL bConference,
|
|
BOOL bSync
|
|
);
|
|
HRESULT OneStepTransfer(
|
|
CCall *pConsultationCall,
|
|
VARIANT_BOOL bSync
|
|
);
|
|
|
|
|
|
public:
|
|
#ifdef NEWCALLINFO
|
|
STDMETHOD(get_Address)(ITAddress ** ppAddress);
|
|
STDMETHOD(get_CallState)(CALL_STATE * pCallState);
|
|
STDMETHOD(get_Privilege)(CALL_PRIVILEGE * pPrivilege);
|
|
STDMETHOD(get_CallHub)(ITCallHub ** ppCallHub);
|
|
STDMETHOD(get_CallInfoLong)(
|
|
CALLINFO_LONG CallInfoLong,
|
|
long * plCallInfoLongVal
|
|
);
|
|
STDMETHOD(put_CallInfoLong)(
|
|
CALLINFO_LONG CallInfoLong,
|
|
long lCallInfoLongVal
|
|
);
|
|
STDMETHOD(get_CallInfoString)(
|
|
CALLINFO_STRING CallInfoString,
|
|
BSTR * ppCallInfoString
|
|
);
|
|
STDMETHOD(put_CallInfoString)(
|
|
CALLINFO_STRING CallInfoString,
|
|
BSTR pCallInfoString
|
|
);
|
|
STDMETHOD(get_CallInfoBuffer)(
|
|
CALLINFO_BUFFER CallInfoBuffer,
|
|
VARIANT * ppCallInfoBuffer
|
|
);
|
|
STDMETHOD(put_CallInfoBuffer)(
|
|
CALLINFO_BUFFER CallInfoBuffer,
|
|
VARIANT pCallInfoBuffer
|
|
);
|
|
STDMETHOD(GetCallInfoBuffer)(
|
|
CALLINFO_BUFFER CallInfoBuffer,
|
|
DWORD * pdwSize,
|
|
BYTE ** ppCallInfoBuffer
|
|
);
|
|
STDMETHOD(SetCallInfoBuffer)(
|
|
CALLINFO_BUFFER CallInfoBuffer,
|
|
DWORD dwSize,
|
|
BYTE * pCallInfoBuffer
|
|
);
|
|
STDMETHOD(ReleaseUserUserInfo)();
|
|
|
|
HRESULT get_MediaTypesAvailable(long * plMediaTypes);
|
|
HRESULT get_CallerIDAddressType(long * plAddressType );
|
|
HRESULT get_CalledIDAddressType(long * plAddressType );
|
|
HRESULT get_ConnectedIDAddressType(long * plAddressType );
|
|
HRESULT get_RedirectionIDAddressType(long * plAddressType );
|
|
HRESULT get_RedirectingIDAddressType(long * plAddressType );
|
|
HRESULT get_BearerMode(long * plBearerMode);
|
|
HRESULT put_BearerMode(long lBearerMode);
|
|
HRESULT get_Origin(long * plOrigin );
|
|
HRESULT get_Reason(long * plReason );
|
|
HRESULT get_CallerIDName(BSTR * ppCallerIDName );
|
|
HRESULT get_CallerIDNumber(BSTR * ppCallerIDNumber );
|
|
HRESULT get_CalledIDName(BSTR * ppCalledIDName );
|
|
HRESULT get_CalledIDNumber(BSTR * ppCalledIDNumber );
|
|
HRESULT get_ConnectedIDName(BSTR * ppConnectedIDName );
|
|
HRESULT get_ConnectedIDNumber(BSTR * ppConnectedIDNumber );
|
|
HRESULT get_RedirectionIDName(BSTR * ppRedirectionIDName );
|
|
HRESULT get_RedirectionIDNumber(BSTR * ppRedirectionIDNumber );
|
|
HRESULT get_RedirectingIDName(BSTR * ppRedirectingIDName );
|
|
HRESULT get_RedirectingIDNumber(BSTR * ppRedirectingIDNumber );
|
|
HRESULT get_CalledPartyFriendlyName(BSTR * ppCalledPartyFriendlyName );
|
|
HRESULT put_CalledPartyFriendlyName(BSTR pCalledPartyFriendlyName );
|
|
HRESULT get_Comment(BSTR * ppComment );
|
|
HRESULT put_Comment(BSTR pComment );
|
|
HRESULT GetUserUserInfo(DWORD * pdwSize, BYTE ** ppBuffer );
|
|
HRESULT SetUserUserInfo(long lSize, BYTE * pBuffer );
|
|
HRESULT get_UserUserInfo(VARIANT * pUUI);
|
|
HRESULT put_UserUserInfo(VARIANT UUI);
|
|
HRESULT get_AppSpecific(long * plAppSpecific );
|
|
HRESULT put_AppSpecific(long lAppSpecific );
|
|
HRESULT GetDevSpecificBuffer(DWORD * pdwSize, BYTE ** ppDevSpecificBuffer);
|
|
HRESULT SetDevSpecificBuffer(long lSize, BYTE * pDevSpecificBuffer);
|
|
HRESULT get_DevSpecificBuffer(VARIANT * pBuffer);
|
|
HRESULT put_DevSpecificBuffer(VARIANT Buffer);
|
|
HRESULT SetCallParamsFlags(long lFlags);
|
|
HRESULT GetCallParamsFlags(long * plFlags);
|
|
HRESULT put_DisplayableAddress(BSTR pDisplayableAddress);
|
|
HRESULT get_DisplayableAddress(BSTR * ppDisplayableAddress);
|
|
HRESULT GetCallDataBuffer(DWORD * pdwSize, BYTE ** ppBuffer);
|
|
HRESULT SetCallDataBuffer(long lSize, BYTE * pBuffer);
|
|
HRESULT put_CallDataBuffer(VARIANT Buffer);
|
|
HRESULT get_CallDataBuffer(VARIANT * pBuffer);
|
|
HRESULT put_CallingPartyID(BSTR pCallingPartyID);
|
|
HRESULT get_CallingPartyID(BSTR * ppCallingPartyID);
|
|
HRESULT put_CallTreatment(long lTreatment);
|
|
HRESULT get_CallTreatment(long * plTreatment);
|
|
HRESULT put_MinRate(long lMinRate);
|
|
HRESULT get_MinRate(long * plMinRate);
|
|
HRESULT put_MaxRate(long lMaxRate);
|
|
HRESULT get_MaxRate(long * plMaxRate);
|
|
HRESULT put_CountryCode(long lCountryCode);
|
|
HRESULT get_CountryCode(long * plCountryCode);
|
|
HRESULT get_CallId(long * plCallId );
|
|
HRESULT get_RelatedCallId(long * plCallId );
|
|
HRESULT get_CompletionId(long * plCompletionId );
|
|
HRESULT get_NumberOfOwners(long * plNumberOfOwners );
|
|
HRESULT get_NumberOfMonitors(long * plNumberOfMonitors );
|
|
HRESULT get_Trunk(long * plTrunk );
|
|
HRESULT GetChargingInfoBuffer(DWORD * pdwSize, BYTE ** ppBuffer);
|
|
HRESULT get_ChargingInfoBuffer(VARIANT * pBuffer );
|
|
HRESULT SetHighLevelCompatibilityBuffer(long lSize, BYTE * pBuffer);
|
|
HRESULT GetHighLevelCompatibilityBuffer(DWORD * pdwSize, BYTE ** ppBuffer);
|
|
HRESULT put_HighLevelCompatibilityBuffer(VARIANT Buffer );
|
|
HRESULT get_HighLevelCompatibilityBuffer(VARIANT * pBuffer );
|
|
HRESULT SetLowLevelCompatibilityBuffer(long lSize, BYTE * pBuffer);
|
|
HRESULT GetLowLevelCompatibilityBuffer(DWORD * pdwSize, BYTE ** ppBuffer);
|
|
HRESULT put_LowLevelCompatibilityBuffer(VARIANT Buffer );
|
|
HRESULT get_LowLevelCompatibilityBuffer(VARIANT * pBuffer );
|
|
HRESULT get_Rate(long * plRate );
|
|
HRESULT put_GenerateDigitDuration( long lGenerateDigitDuration );
|
|
HRESULT get_GenerateDigitDuration( long * plGenerateDigitDuration );
|
|
HRESULT get_MonitorDigitModes( long * plMonitorDigitModes );
|
|
HRESULT get_MonitorMediaModes( long * plMonitorMediaModes );
|
|
|
|
#else
|
|
|
|
// ITCallInfo methods
|
|
STDMETHOD(get_Address)(ITAddress ** ppAddress);
|
|
STDMETHOD(get_CallState)(CALL_STATE * pCallState);
|
|
STDMETHOD(get_Privilege)(CALL_PRIVILEGE * pPrivilege);
|
|
STDMETHOD(get_MediaTypesAvailable)(long * plMediaTypes);
|
|
STDMETHOD(get_CallHub)(ITCallHub ** ppCallHub);
|
|
STDMETHOD(get_AddressType)(long * plAddressType );
|
|
STDMETHOD(put_AddressType)(long lAddressType );
|
|
STDMETHOD(get_BearerMode)(long * plBearerMode);
|
|
STDMETHOD(put_BearerMode)(long lBearerMode);
|
|
STDMETHOD(get_Origin)(long * plOrigin );
|
|
STDMETHOD(get_Reason)(long * plReason );
|
|
STDMETHOD(get_CallerIDName)(BSTR * ppCallerIDName );
|
|
STDMETHOD(get_CallerIDNumber)(BSTR * ppCallerIDNumber );
|
|
STDMETHOD(get_CalledIDName)(BSTR * ppCalledIDName );
|
|
STDMETHOD(get_CalledIDNumber)(BSTR * ppCalledIDNumber );
|
|
STDMETHOD(get_ConnectedIDName)(BSTR * ppConnectedIDName );
|
|
STDMETHOD(get_ConnectedIDNumber)(BSTR * ppConnectedIDNumber );
|
|
STDMETHOD(get_RedirectionIDName)(BSTR * ppRedirectionIDName );
|
|
STDMETHOD(get_RedirectionIDNumber)(BSTR * ppRedirectionIDNumber );
|
|
STDMETHOD(get_RedirectingIDName)(BSTR * ppRedirectingIDName );
|
|
STDMETHOD(get_RedirectingIDNumber)(BSTR * ppRedirectingIDNumber );
|
|
STDMETHOD(get_CalledPartyFriendlyName)(BSTR * ppCalledPartyFriendlyName );
|
|
STDMETHOD(put_CalledPartyFriendlyName)(BSTR pCalledPartyFriendlyName );
|
|
STDMETHOD(get_Comment)(BSTR * ppComment );
|
|
STDMETHOD(put_Comment)(BSTR pComment );
|
|
STDMETHOD(GetUserUserInfoSize)(long * plSize );
|
|
STDMETHOD(GetUserUserInfo)(long lSize, BYTE * pBuffer );
|
|
STDMETHOD(SetUserUserInfo)(long lSize, BYTE * pBuffer );
|
|
STDMETHOD(get_UserUserInfo)(VARIANT * pUUI);
|
|
STDMETHOD(put_UserUserInfo)(VARIANT UUI);
|
|
STDMETHOD(ReleaseUserUserInfo)();
|
|
STDMETHOD(get_AppSpecific)(long * plAppSpecific );
|
|
STDMETHOD(put_AppSpecific)(long lAppSpecific );
|
|
STDMETHOD(GetDevSpecificBufferSize)(long * plDevSpecificSize );
|
|
STDMETHOD(GetDevSpecificBuffer)(long lSize, BYTE * pDevSpecificBuffer);
|
|
STDMETHOD(SetDevSpecificBuffer)(long lSize, BYTE * pDevSpecificBuffer);
|
|
STDMETHOD(get_DevSpecificBuffer)(VARIANT * pBuffer);
|
|
STDMETHOD(put_DevSpecificBuffer)(VARIANT Buffer);
|
|
STDMETHOD(SetCallParamsFlags)(long lFlags);
|
|
STDMETHOD(put_DisplayableAddress)(BSTR pDisplayableAddress);
|
|
STDMETHOD(get_DisplayableAddress)(BSTR * ppDisplayableAddress);
|
|
STDMETHOD(GetCallDataBufferSize)(long * plSize);
|
|
STDMETHOD(GetCallDataBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD(SetCallDataBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD(put_CallDataBuffer)(VARIANT Buffer);
|
|
STDMETHOD(get_CallDataBuffer)(VARIANT * pBuffer);
|
|
STDMETHOD(put_CallingPartyID)(BSTR pCallingPartyID);
|
|
STDMETHOD(get_CallingPartyID)(BSTR * ppCallingPartyID);
|
|
STDMETHOD(put_CallTreatment)(long lTreatment);
|
|
STDMETHOD(get_CallTreatment)(long * plTreatment);
|
|
STDMETHOD(put_MinRate)(long lMinRate);
|
|
STDMETHOD(get_MinRate)(long * plMinRate);
|
|
STDMETHOD(put_MaxRate)(long lMaxRate);
|
|
STDMETHOD(get_MaxRate)(long * plMaxRate);
|
|
STDMETHOD(put_CountryCode)(long lCountryCode);
|
|
|
|
STDMETHOD (get_CallId)(long * plCallId );
|
|
STDMETHOD (get_RelatedCallId)(long * plCallId );
|
|
STDMETHOD (get_CompletionId)(long * plCompletionId );
|
|
STDMETHOD (get_NumberOfOwners)(long * plNumberOfOwners );
|
|
STDMETHOD (get_NumberOfMonitors)(long * plNumberOfMonitors );
|
|
STDMETHOD (get_Trunk)(long * plTrunk );
|
|
|
|
STDMETHOD (GetChargingInfoBufferSize)(long * plSize );
|
|
STDMETHOD (GetChargingInfoBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD (get_ChargingInfoBuffer)(VARIANT * pBuffer );
|
|
|
|
STDMETHOD (GetHighLevelCompatibilityBufferSize)(long * plSize );
|
|
STDMETHOD (SetHighLevelCompatibilityBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD (GetHighLevelCompatibilityBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD (put_HighLevelCompatibilityBuffer)(VARIANT Buffer );
|
|
STDMETHOD (get_HighLevelCompatibilityBuffer)(VARIANT * pBuffer );
|
|
|
|
STDMETHOD (GetLowLevelCompatibilityBufferSize)(long * plSize );
|
|
|
|
STDMETHOD (SetLowLevelCompatibilityBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD (GetLowLevelCompatibilityBuffer)(long lSize, BYTE * pBuffer);
|
|
STDMETHOD (put_LowLevelCompatibilityBuffer)(VARIANT Buffer );
|
|
STDMETHOD (get_LowLevelCompatibilityBuffer)(VARIANT * pBuffer );
|
|
STDMETHOD (get_Rate)(long * plRate );
|
|
#endif
|
|
|
|
// ITCallInfo2
|
|
STDMETHOD(get_EventFilter)(
|
|
TAPI_EVENT TapiEvent,
|
|
long lSubEvent,
|
|
VARIANT_BOOL* pEnable
|
|
);
|
|
|
|
STDMETHOD(put_EventFilter)(
|
|
TAPI_EVENT TapiEvent,
|
|
long lSubEvent,
|
|
VARIANT_BOOL bEnable
|
|
);
|
|
|
|
// ITBasicCallControl methods
|
|
STDMETHOD(Connect)(VARIANT_BOOL bSync);
|
|
STDMETHOD(Answer)(void);
|
|
STDMETHOD(Disconnect)(DISCONNECT_CODE code);
|
|
STDMETHOD(Hold)(VARIANT_BOOL bHold);
|
|
STDMETHOD(HandoffDirect)(BSTR pApplicationName);
|
|
STDMETHOD(HandoffIndirect)(long lMediaType);
|
|
STDMETHOD(Conference)(
|
|
ITBasicCallControl * pCall,
|
|
VARIANT_BOOL bSync
|
|
);
|
|
STDMETHOD(CreateConference)(
|
|
CCall * pConsultationCall,
|
|
VARIANT_BOOL bSync
|
|
);
|
|
STDMETHOD(AddToConference)(
|
|
CCall * pConsultationCall,
|
|
VARIANT_BOOL bSync
|
|
);
|
|
STDMETHOD(BlindTransfer)(BSTR pDestAddress);
|
|
STDMETHOD(Transfer)(
|
|
ITBasicCallControl * pCall,
|
|
VARIANT_BOOL bSync
|
|
);
|
|
STDMETHOD(SwapHold)(ITBasicCallControl * pCall);
|
|
STDMETHOD(ParkDirect)(BSTR pParkAddress);
|
|
STDMETHOD(ParkIndirect)(BSTR * ppNonDirAddress);
|
|
STDMETHOD(Unpark)();
|
|
STDMETHOD(SetQOS)(
|
|
long lMediaType,
|
|
QOS_SERVICE_LEVEL ServiceLevel
|
|
);
|
|
STDMETHOD(Pickup)( BSTR pGroupID );
|
|
STDMETHOD(Dial)( BSTR pDestAddress );
|
|
STDMETHOD(Finish)(FINISH_MODE finishMode);
|
|
STDMETHOD(RemoveFromConference)(void);
|
|
|
|
// ITBasicCallControl2
|
|
STDMETHOD(RequestTerminal)(
|
|
IN BSTR bstrTerminalClassGUID,
|
|
IN long lMediaType,
|
|
IN TERMINAL_DIRECTION Direction,
|
|
OUT ITTerminal** ppTerminal
|
|
);
|
|
|
|
STDMETHOD(SelectTerminalOnCall)(
|
|
IN ITTerminal *pTerminal
|
|
);
|
|
|
|
STDMETHOD(UnselectTerminalOnCall)(
|
|
IN ITTerminal *pTerminal
|
|
);
|
|
|
|
// ITLegacyCallMediaControl
|
|
STDMETHOD(DetectDigits)(TAPI_DIGITMODE DigitMode);
|
|
STDMETHOD(GenerateDigits)(
|
|
BSTR pDigits,
|
|
TAPI_DIGITMODE DigitMode
|
|
);
|
|
STDMETHOD(GetID)(
|
|
BSTR pDeviceClass,
|
|
DWORD * pdwSize,
|
|
BYTE ** ppDeviceID
|
|
);
|
|
STDMETHOD(SetMediaType)(long lMediaType);
|
|
STDMETHOD(MonitorMedia)(long lMediaType);
|
|
|
|
// ITLegacyCallMediaControl2
|
|
STDMETHOD(GenerateDigits2)(
|
|
BSTR pDigits,
|
|
TAPI_DIGITMODE DigitMode,
|
|
long lDuration
|
|
);
|
|
|
|
STDMETHOD(GatherDigits)(
|
|
TAPI_DIGITMODE DigitMode,
|
|
long lNumDigits,
|
|
BSTR pTerminationDigits,
|
|
long lFirstDigitTimeout,
|
|
long lInterDigitTimeout
|
|
);
|
|
|
|
STDMETHOD(DetectTones)(
|
|
TAPI_DETECTTONE * pToneList,
|
|
long lNumTones
|
|
);
|
|
|
|
STDMETHOD(DetectTonesByCollection)(
|
|
ITCollection2 * pDetectToneCollection
|
|
);
|
|
|
|
STDMETHOD(GenerateTone)(
|
|
TAPI_TONEMODE ToneMode,
|
|
long lDuration
|
|
);
|
|
|
|
STDMETHOD(GenerateCustomTones)(
|
|
TAPI_CUSTOMTONE * pToneList,
|
|
long lNumTones,
|
|
long lDuration
|
|
);
|
|
|
|
STDMETHOD(GenerateCustomTonesByCollection)(
|
|
ITCollection2 * pCustomToneCollection,
|
|
long lDuration
|
|
);
|
|
|
|
STDMETHOD(CreateDetectToneObject)(
|
|
ITDetectTone ** ppDetectTone
|
|
);
|
|
|
|
STDMETHOD(CreateCustomToneObject)(
|
|
ITCustomTone ** ppCustomTone
|
|
);
|
|
|
|
STDMETHOD(GetIDAsVariant)(IN BSTR bstrDeviceClass,
|
|
OUT VARIANT *pVarDeviceID);
|
|
|
|
|
|
// IDispatch Methods
|
|
STDMETHOD(GetIDsOfNames)(REFIID riid,
|
|
LPOLESTR* rgszNames,
|
|
UINT cNames,
|
|
LCID lcid,
|
|
DISPID* rgdispid
|
|
);
|
|
STDMETHOD(Invoke)(DISPID dispidMember,
|
|
REFIID riid,
|
|
LCID lcid,
|
|
WORD wFlags,
|
|
DISPPARAMS* pdispparams,
|
|
VARIANT* pvarResult,
|
|
EXCEPINFO* pexcepinfo,
|
|
UINT* puArgErr
|
|
);
|
|
|
|
|
|
STDMETHOD_(ULONG, InternalAddRef)()
|
|
{
|
|
DWORD dwR;
|
|
|
|
dwR = InterlockedIncrement(&m_dwRef);;
|
|
|
|
#if DBG
|
|
LogDebugAddRef(m_dwRef);
|
|
#endif
|
|
|
|
return dwR;
|
|
}
|
|
|
|
|
|
STDMETHOD_(ULONG, InternalRelease)()
|
|
{
|
|
|
|
Lock();
|
|
|
|
LOG((TL_INFO, "InternalRelease - enter m_dwRef = %ld", m_dwRef));
|
|
|
|
|
|
gpCallHashTable->Lock();
|
|
gpHandleHashTable->Lock();
|
|
|
|
DWORD dwR = InterlockedDecrement(&m_dwRef);
|
|
|
|
// if ref count is 1 (means we entered function with 2) then we final release
|
|
if (1 == dwR)
|
|
{
|
|
// make sure we only call ExternalFinalRelease & delete once
|
|
if(m_bReleased == FALSE)
|
|
{
|
|
m_bReleased = TRUE;
|
|
|
|
LOG((TL_TRACE, "InternalRelease - final" ));
|
|
|
|
// remove from the hash table, so any more messages
|
|
// from tapisrv are ignored
|
|
//
|
|
gpCallHashTable->Remove( (ULONG_PTR)(m_t3Call.hCall) );
|
|
gpCallHashTable->Unlock();
|
|
|
|
// remove from the handle hash table, so any more messages
|
|
// from msp are ignored
|
|
//
|
|
RemoveHandleFromHashTable((ULONG_PTR)m_MSPCallHandle);
|
|
gpHandleHashTable->Unlock();
|
|
|
|
|
|
ExternalFinalRelease();
|
|
dwR = m_dwRef = 0;
|
|
|
|
Unlock();
|
|
|
|
}
|
|
else
|
|
{
|
|
gpCallHashTable->Unlock();
|
|
gpHandleHashTable->Unlock();
|
|
Unlock();
|
|
LOG((TL_INFO, "InternalRelease - m_bReleased is TRUE. dwR[%ld]", dwR));
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
gpCallHashTable->Unlock();
|
|
gpHandleHashTable->Unlock();
|
|
Unlock();
|
|
}
|
|
|
|
|
|
|
|
#if DBG
|
|
LogDebugRelease( dwR );
|
|
#endif
|
|
|
|
|
|
LOG((TL_INFO, "InternalRelease - exit. refcount %ld", dwR));
|
|
|
|
return dwR;
|
|
}
|
|
|
|
protected:
|
|
HRESULT SelectSingleTerminalOnCall(
|
|
IN ITTerminal* pTerminal,
|
|
OUT long* pMediaType,
|
|
OUT TERMINAL_DIRECTION* pDirection);
|
|
|
|
HRESULT SelectMultiTerminalOnCall(
|
|
IN ITMultiTrackTerminal* pTerminal);
|
|
|
|
HRESULT IsRightStream(
|
|
IN ITStream* pStream,
|
|
IN ITTerminal* pTerminal,
|
|
OUT long* pMediaType = NULL,
|
|
OUT TERMINAL_DIRECTION* pDirection = NULL);
|
|
|
|
int GetStreamIndex(
|
|
IN long lMediaType,
|
|
IN TERMINAL_DIRECTION Direction);
|
|
|
|
HRESULT UnSelectSingleTerminalFromCall(
|
|
IN ITTerminal* pTerminal);
|
|
|
|
HRESULT UnSelectMultiTerminalFromCall(
|
|
IN ITMultiTrackTerminal* pTerminal);
|
|
|
|
//
|
|
// Helper methods for CreateTerminal
|
|
//
|
|
BOOL IsStaticGUID(
|
|
BSTR bstrTerminalGUID);
|
|
|
|
HRESULT CreateStaticTerminal(
|
|
IN BSTR bstrTerminalClassGUID,
|
|
IN TERMINAL_DIRECTION Direction,
|
|
IN long lMediaType,
|
|
OUT ITTerminal** ppTerminal
|
|
);
|
|
|
|
HRESULT CreateDynamicTerminal(
|
|
IN BSTR bstrTerminalClassGUID,
|
|
IN TERMINAL_DIRECTION Direction,
|
|
IN long lMediaType,
|
|
OUT ITTerminal** ppTerminal
|
|
);
|
|
public:
|
|
//
|
|
// Sets the subevent flag
|
|
//
|
|
HRESULT SetSubEventFlag(
|
|
IN TAPI_EVENT TapiEvent,
|
|
IN DWORD dwSubEvent,
|
|
IN BOOL bEnable
|
|
);
|
|
|
|
HRESULT GetSubEventFlag(
|
|
TAPI_EVENT TapiEvent,
|
|
DWORD dwSubEvent,
|
|
BOOL* pEnable
|
|
);
|
|
|
|
// Get subevents mask
|
|
DWORD GetSubEventsMask(
|
|
IN TAPI_EVENT TapiEvent
|
|
);
|
|
|
|
//Get the conference controller call object if one exists.
|
|
CCall* GetConfControlCall();
|
|
|
|
private:
|
|
//
|
|
// Helper methods for event filtering
|
|
//
|
|
|
|
CEventMasks m_EventMasks;
|
|
|
|
HRESULT IsTerminalSelected(
|
|
IN ITTerminal* pTerminal,
|
|
OUT BOOL* pSelected
|
|
);
|
|
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDetectTone
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
class CDetectTone :
|
|
public CTAPIComObjectRoot<CDetectTone>,
|
|
public IDispatchImpl<ITDetectTone, &IID_ITDetectTone, &LIBID_TAPI3Lib>,
|
|
public CObjectSafeImpl
|
|
{
|
|
public:
|
|
|
|
CDetectTone()
|
|
{
|
|
m_lAppSpecific = 0;
|
|
m_lDuration = 0;
|
|
m_lFrequency[0] = 0;
|
|
m_lFrequency[1] = 0;
|
|
m_lFrequency[2] = 0;
|
|
}
|
|
|
|
DECLARE_MARSHALQI(CDetectTone)
|
|
DECLARE_QI()
|
|
DECLARE_TRACELOG_CLASS(CDetectTone)
|
|
|
|
BEGIN_COM_MAP(CDetectTone)
|
|
COM_INTERFACE_ENTRY(IDispatch)
|
|
COM_INTERFACE_ENTRY(ITDetectTone)
|
|
COM_INTERFACE_ENTRY(IObjectSafety)
|
|
COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
|
|
COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
|
|
END_COM_MAP()
|
|
|
|
protected:
|
|
|
|
long m_lAppSpecific;
|
|
long m_lDuration;
|
|
long m_lFrequency[3];
|
|
|
|
public:
|
|
|
|
STDMETHOD(put_AppSpecific)( long lAppSpecific );
|
|
STDMETHOD(get_AppSpecific)( long * plAppSpecific );
|
|
STDMETHOD(put_Duration)( long lDuration );
|
|
STDMETHOD(get_Duration)( long * plDuration );
|
|
STDMETHOD(put_Frequency)(
|
|
long Index,
|
|
long lFrequency
|
|
);
|
|
STDMETHOD(get_Frequency)(
|
|
long Index,
|
|
long * plFrequency
|
|
);
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCustomTone
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
class CCustomTone :
|
|
public CTAPIComObjectRoot<CCustomTone>,
|
|
public IDispatchImpl<ITCustomTone, &IID_ITCustomTone, &LIBID_TAPI3Lib>,
|
|
public CObjectSafeImpl
|
|
{
|
|
public:
|
|
|
|
CCustomTone()
|
|
{
|
|
m_lFrequency = 0;
|
|
m_lCadenceOn = 0;
|
|
m_lCadenceOff = 0;
|
|
m_lVolume = 0;
|
|
}
|
|
|
|
DECLARE_MARSHALQI(CCustomTone)
|
|
DECLARE_QI()
|
|
DECLARE_TRACELOG_CLASS(CCustomTone)
|
|
|
|
BEGIN_COM_MAP(CCustomTone)
|
|
COM_INTERFACE_ENTRY2(IDispatch, ITCustomTone)
|
|
COM_INTERFACE_ENTRY(ITCustomTone)
|
|
COM_INTERFACE_ENTRY(IObjectSafety)
|
|
COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
|
|
COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
|
|
END_COM_MAP()
|
|
|
|
protected:
|
|
|
|
long m_lFrequency;
|
|
long m_lCadenceOn;
|
|
long m_lCadenceOff;
|
|
long m_lVolume;
|
|
|
|
|
|
public:
|
|
|
|
STDMETHOD(put_Frequency)( long lFrequency );
|
|
STDMETHOD(get_Frequency)( long * plFrequency );
|
|
STDMETHOD(put_CadenceOn)( long lCadenceOn );
|
|
STDMETHOD(get_CadenceOn)( long * plCadenceOn );
|
|
STDMETHOD(put_CadenceOff)( long lCadenceOff );
|
|
STDMETHOD(get_CadenceOff)( long * plCadenceOff );
|
|
STDMETHOD(put_Volume)( long lVolume );
|
|
STDMETHOD(get_Volume)( long * plVolume );
|
|
};
|
|
|
|
|
|
#endif //__CALL_H_
|