io Programmo 10/ioProg_10.iso/soft/platsdk/inetwork.exe/TAPI-S.cab/65INCOMING.CPP

C/C++ Source or Header | 1997-09-10 | 26.7 KB | 1,084 lines

#define UNICODE
#include <list>
#include <windows.h>
#include <tapi3.h>
#include "callnot.h"
#include "resource.h"

//////////////////////////////////////////////////////////
// T3IN.EXE
//
// Sample application that handling incoming TAPI calls.
// In order to receive incoming calls, the application must
// implement and register the outgoing ITCallNotification
// interface.
//
// This application will register to recieve calls on
// all addresses that support at least audioin and audioout.
//
// NOTE:  This application is limited to working with one call at
// at time, and will not work correctly if multiple calls
// are present at the same time.
//////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////
// constants
//////////////////////////////////////////////////////////

const DWORD MAXTERMINALS    = 5;

//////////////////////////////////////////////////////////
// TYPEDEFS
//////////////////////////////////////////////////////////

using namespace std;
typedef list<CCallNotification *> CCallNotificationPtrList;


//////////////////////////////////////////////////////////
// GLOBALS
//////////////////////////////////////////////////////////

HINSTANCE               ghInst;
ITTAPI *                gpTapi;
ITBasicCallControl *    gpCall;
HWND                    ghDlg = NULL;

BSTR                    gbstrAudioIn;
BSTR                    gbstrAudioOut;
BSTR                    gbstrVideoIn;
BSTR                    gbstrVideoOut;

WCHAR gszTapi30[] = L"TAPI 3.0 Incoming Call Sample";

// list of outgoing interface objects we have registered
CCallNotificationPtrList gpCallNotificationList;

//////////////////////////////////////////////////////////
// PROTOTYPES
//////////////////////////////////////////////////////////
BOOL
CALLBACK
MainDialogProc(
               HWND hDlg,
               UINT uMsg,
               WPARAM wParam,
               LPARAM lParam
              );

HRESULT
GetMediaTerminal(
                 ITAddress *,
                 BSTR bstrMedia,
                 ITMediaTerminal ** ppMediaTerminal
                );
HRESULT
ListenOnAddresses();

HRESULT
ListenOnThisAddress(
                    ITAddress * pAddress
                   );

HRESULT
AnswerTheCall();

HRESULT
DisconnectTheCall();

void
ReleaseTheCall();

void
DoMessage(
          LPWSTR pszMessage
         );

void
SetStatusMessage(
                 LPWSTR pszMessage
                );

HRESULT
InitializeTapi();

void
ShutdownTapi();

void
EnableButton(
             int ID
            );
void
DisableButton(
              int ID
             );

//////////////////////////////////////////////////////////
//
//              FUNCTIONS
//
//////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////
// WinMain
//////////////////////////////////////////////////////////
int
WINAPI
WinMain(
        HINSTANCE hInst,
        HINSTANCE hPrevInst,
        LPSTR lpCmdLine,
        int nCmdShow
       )
{
    ghInst = hInst;


    // need to coinit
    if (!SUCCEEDED(CoInitialize(NULL)))
    {
        return 0;
    }

    // do all tapi initialization
    if (S_OK != InitializeTapi())
    {
        return 0;
    }

    // everything is initialized, so
    // start the main dialog box
    DialogBox(
              ghInst,
              MAKEINTRESOURCE(IDD_MAINDLG),
              NULL,
              MainDialogProc
             );


    // clean up
    ShutdownTapi();

    CoUninitialize();

    return 1;
}


//////////////////////////////////////////////////////////////
// InitializeTapi
//
// Various initializations
///////////////////////////////////////////////////////////////
HRESULT
InitializeTapi()
{
    HRESULT         hr;
    LPWSTR          psz;


    // cocreate the TAPI object
    hr = CoCreateInstance(
                          CLSID_TAPI,
                          NULL,
                          CLSCTX_INPROC_SERVER,
                          IID_ITTAPI,
                          (LPVOID *)&gpTapi
                         );

    if (hr != S_OK)
    {
        DoMessage(L"CoCreateInstance on TAPI failed");
        return hr;
    }

    // call initialize.  this must be called before
    // any other tapi functions are called.
    hr = gpTapi->Initialize();

    if (S_OK != hr)
    {
        DoMessage(L"TAPI failed to initialize");

        gpTapi->Release();
        gpTapi = NULL;

        return hr;
    }


    // convert the TAPIMEDIATYPEs to BSTRs for
    // convenience throughout the program

    StringFromIID( TAPIMEDIATYPE_AudioIn, &psz );
    gbstrAudioIn = SysAllocString( psz );
    CoTaskMemFree( psz );

    StringFromIID( TAPIMEDIATYPE_AudioOut, &psz );
    gbstrAudioOut = SysAllocString( psz );
    CoTaskMemFree( psz );

    StringFromIID( TAPIMEDIATYPE_VideoIn, &psz );
    gbstrVideoIn = SysAllocString( psz );
    CoTaskMemFree( psz );

    StringFromIID( TAPIMEDIATYPE_VideoOut, &psz );
    gbstrVideoOut = SysAllocString( psz );
    CoTaskMemFree( psz );

    // find all address objects that
    // we will use to listen for calls on
    hr = ListenOnAddresses();

    if (S_OK != hr)
    {
        DoMessage(L"Could not find any addresses to listen on");

        gpTapi->Release();
        gpTapi = NULL;

        return hr;
    }

    return S_OK;

}


///////////////////////////////////////////////////////////////
// ShutdownTapi
///////////////////////////////////////////////////////////////
void
ShutdownTapi()
{
    CCallNotificationPtrList::iterator i;
    // if there is still a call,
    // release it
    if (NULL != gpCall)
    {
        gpCall->Release();
        gpCall = NULL;
    }


    // Release all CallNotification objects
    for (
         i = gpCallNotificationList.begin();
         i != gpCallNotificationList.end();
         i++
        )
    {

        (*i)->Shutdown();

        // At this point, we should call Unadvise on
        // the ConnectionPoint.  However, TAPI 3.0
        // does not support Unadvise for the ITCallNotification
        // interface.  So, here we just release the object
        (*i)->Release();
    }

    // release main object.
    if (NULL != gpTapi)
    {
        gpTapi->Shutdown();
        gpTapi->Release();
    }

    // free the BSTRs
    SysFreeString( gbstrAudioIn );
    SysFreeString( gbstrAudioOut );
    SysFreeString( gbstrVideoIn );
    SysFreeString( gbstrVideoOut );
}


///////////////////////////////////////////////////////////////////////////
// MainDlgProc
///////////////////////////////////////////////////////////////////////////
BOOL
CALLBACK
MainDialogProc(
               HWND hDlg,
               UINT uMsg,
               WPARAM wParam,
               LPARAM lParam
              )
{
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            // set up dialog
            ghDlg = hDlg;

            DisableButton( IDC_ANSWER );
            DisableButton( IDC_DISCONNECT );

            SetStatusMessage( L"Waiting for a call..." );

            return 0;
        }

        case WM_COMMAND:
        {
            if ( LOWORD(wParam) == IDCANCEL )
            {
                // quit
                EndDialog( hDlg, 0 );

                return 1;
            }

            switch ( LOWORD(wParam) )
            {
                // dial request
                case IDC_ANSWER:
                {
                    SetStatusMessage(L"Answering...");
                    // answer the call
                    if ( S_OK == AnswerTheCall() )
                    {
                        SetStatusMessage(L"Connected");

                        EnableButton( IDC_DISCONNECT );
                        DisableButton( IDC_ANSWER );
                    }
                    else
                    {
                        DisableButton( IDC_ANSWER );
                        DoMessage(L"Answer failed");
                        SetStatusMessage(L"Waiting for a call...");
                    }

                    return 1;
                }

                // disconnect request
                case IDC_DISCONNECT:
                {
                    SetStatusMessage(L"Disconnecting...");
                    // disconnect
                    if (S_OK != DisconnectTheCall())
                    {
                        DoMessage(L"Disconnect failed");
                    }

                    return 1;
                }

                // disconnected notification
                case IDC_DISCONNECTED:
                {
                    // release
                    ReleaseTheCall();

                    EnableButton( IDOK );
                    DisableButton( IDC_DISCONNECT );

                    SetStatusMessage(L"Waiting for a call...");

                    return 1;
                }
                default:

                    return 0;
            }
        }
        default:

            return 0;
    }
}


////////////////////////////////////////////////////////////////////////
// ListenOnAddresses
//
// This procedure will find all addresses that support audioin and audioout
// and will call ListenOnThisAddress to start listening on it.
////////////////////////////////////////////////////////////////////////
HRESULT
ListenOnAddresses()
{
    HRESULT             hr = S_OK;
    IEnumAddress *      pEnumAddress;
    ITAddress *         pAddress;
    ITMediaSupport *    pMediaSupport;
    VARIANT_BOOL        bSupport;

    // enumerate the addresses
    hr = gpTapi->_EnumerateAddresses( &pEnumAddress );

    if (S_OK != hr)
    {
        return hr;
    }

    while ( TRUE )
    {
        // get the next address
        hr = pEnumAddress->Next( 1, &pAddress, NULL );

        if (S_OK != hr)
        {
            break;
        }

        pAddress->QueryInterface( IID_ITMediaSupport, (void **)&pMediaSupport );

        // does it support AudioIn?
        pMediaSupport->QueryMediaType(
                                      gbstrAudioIn,
                                      &bSupport
                                     );

        if (bSupport)
        {
            // does it also support AudioOut?
            pMediaSupport->QueryMediaType(
                                          gbstrAudioOut,
                                          &bSupport
                                         );

            if (bSupport)
            {
                // listen
                hr = ListenOnThisAddress( pAddress );
                if (S_OK != hr)
                {
                    DoMessage(L"Listen failed on an address");
                }
            }
        }

        pMediaSupport->Release();
        pAddress->Release();
    }

    pEnumAddress->Release();

    return S_OK;
}


///////////////////////////////////////////////////////////////////
// ListenOnThisAddress
//
// Perform the steps involved in setting up an address to listen
// for calls.  Setting up an application to listen for calls is a two
// step process.
//
// First, the app must call RegisterCallTypes
// on the address that it wants calls on
//
// Second, it must register it's implementation of ITCallNotification
// with the address.  Registration is done via COM's ConnectionPoint
// methods.  See the COM documentation for more informations on
// ConnectionPoints
//
///////////////////////////////////////////////////////////////////
HRESULT
ListenOnThisAddress(
                    ITAddress * pAddress
                   )
{
    HRESULT hr = S_OK;
    IConnectionPointContainer * pCPC;
    IConnectionPoint *          pCP;
    CCallNotification *         pCallNotification;
    DWORD                       dwCookie;
    VARIANT var;

    // RegisterCallTypes takes an array (in a variant) of
    // MediaTypes for the address to listen for.
    // If NULL is specified for the array, that means to listen
    // for all the media types that the address supports.
    //
    // Since we already know the address supports audioin/audioout,
    // just tell it to listen for all types.  Also, we will tell
    // it that we are only interested in being the owner of calls,
    // not monitoring

    VariantInit( &var );
    var.vt = VT_ARRAY;
    var.parray = NULL;

    hr = pAddress->RegisterCallTypes(
                                     FALSE,
                                     TRUE,  // Want to be owner
                                     FALSE, // Don't want to be monitor
                                     var    // mediatypes
                                    );

    if (S_OK != hr)
    {
        return hr;
    }

    // now we need to register our outgoing interface through
    // the ConnectionPoint methods.

    // First we create our CCallNotification object
    pCallNotification = new CCallNotification;

    if (NULL == pCallNotification)
    {
        return E_OUTOFMEMORY;
    }

    // initialize the object
    hr = pCallNotification->Initialize( pAddress );

    if (S_OK != hr)
    {
        pCallNotification->Release();
        return hr;
    }

    // get the IConnectionPointContainer interface
    // from the address object
    hr = pAddress->QueryInterface(
                                  IID_IConnectionPointContainer,
                                  (void **)&pCPC
                                 );

    if (S_OK != hr)
    {
        pCallNotification->Release();
        pCallNotification = NULL;
        return hr;
    }

    // find the ConnectionPoint we are interested in
    hr = pCPC->FindConnectionPoint( IID_ITCallNotification, &pCP );

    pCPC->Release();

    if (S_OK != hr)
    {
        pCallNotification->Release();
        pCallNotification = NULL;
        return hr;
    }

    // call the advise function
    //
    // if this function succeeds, the address will start
    // listening for calls.
    hr = pCP->Advise(
                     (IUnknown *)pCallNotification,
                     &dwCookie
                    );

    pCP->Release();

    if (S_OK != hr)
    {
        pCallNotification->Release();
        pCallNotification = NULL;
        return hr;
    }

    // save the notification object
    // note that normally you would want
    // to save the dwCookie as well.  Refer
    // to the COM ConnectionPoint documentation
    // for more details.
    gpCallNotificationList.push_back( pCallNotification );

    return S_OK;
}

/////////////////////////////////////////////////////////
// GetMediaTerminal
//
// Creates a MediaTerminal for the bstrMediaType passed
// in, using the default terminal for the bstrMediaType
//
/////////////////////////////////////////////////////////
HRESULT
GetMediaTerminal(
                 ITAddress * pAddress,
                 BSTR bstrMediaType,
                 ITMediaTerminal ** ppMediaTerminal
                )
{
    HRESULT             hr = S_OK;
    ITTerminalSupport * pTerminalSupport;
    ITTerminal *        pTerminal;

    // get the terminal support interface
    pAddress->QueryInterface( IID_ITTerminalSupport, (void **)&pTerminalSupport );

    // get the default terminal for MediaType
    hr = pTerminalSupport->GetDefaultTerminal(
                                              bstrMediaType,
                                              &pTerminal
                                             );


    pTerminalSupport->Release();

    if (S_OK != hr)
    {
        return hr;
    }

    // Create a media terminal for MediaType
    // Use the default terminal we just got
    hr = gpTapi->CreateMediaTerminal(
                                     bstrMediaType,
                                     pTerminal,
                                     ppMediaTerminal
                                    );

    pTerminal->Release();

    if (S_OK != hr)
    {
        return hr;
    }

    return S_OK;

}

/////////////////////////////////////////////////////////
// GetVideoInMediaTerminal
//
// Creates a MediaTerminal for the VideoIn mediatype
// This is a dynamic terminal type.
//
/////////////////////////////////////////////////////////
HRESULT
GetVideoInMediaTerminal(
                 ITAddress * pAddress,
                 ITMediaTerminal ** ppMediaTerminal
                )
{
    HRESULT             hr = S_OK;
    ITTerminalSupport * pTerminalSupport;
    ITTerminal *        pTerminal;

    // get the terminal support interface
    pAddress->QueryInterface( IID_ITTerminalSupport, (void **)&pTerminalSupport );

    BSTR bstrTerminalClass;
    LPOLESTR lpTerminalClass;

    StringFromIID(
                CLSID_VideoWindowTerm,
                &lpTerminalClass
                );

    bstrTerminalClass = SysAllocString ( lpTerminalClass );

    CoTaskMemFree( lpTerminalClass );

    hr = pTerminalSupport->CreateTerminal(
        bstrTerminalClass,
        &pTerminal
        );

    SysFreeString( bstrTerminalClass );
    pTerminalSupport->Release();

    if (FAILED(hr))
    {
        return hr;
    }

    // Create a media terminal for MediaType
    // Use the default terminal we just got
    hr = gpTapi->CreateMediaTerminal(
                                     gbstrVideoIn,
                                     pTerminal,
                                     ppMediaTerminal
                                    );

    pTerminal->Release();

    if (S_OK != hr)
    {
        return hr;
    }

    return S_OK;

}

/////////////////////////////////////////////////////////////////
// CreateMediaTerminals
//
// Create audioin and audioout terminals. Videoin and videoout terminals
// are created only when the address supports them.
//
// This function assumes that ppMediaTerminals has a size no less than four.
/////////////////////////////////////////////////////////////////
HRESULT
CreateMediaTerminals(
                     ITAddress *pAddress,
                     ITMediaTerminal ** ppMediaTerminals,
                     PLONG pNumMediaTerminals
                    )
{
    int count = 0;
    HRESULT hr;

    // get the mediaterminal for audioin
    hr = GetMediaTerminal(
                          pAddress,
                          gbstrAudioIn,
                          &ppMediaTerminals[count]
                         );

    if (S_OK != hr)
    {
        return hr;
    }

    count ++;

    // get the mediaterminal for audioout
    hr = GetMediaTerminal(
                          pAddress,
                          gbstrAudioOut,
                          &ppMediaTerminals[count]
                         );

    if (S_OK != hr)
    {
        ppMediaTerminals[0]->Release();
        return hr;
    }

    count ++;

    // Find out if the address supports video.
    ITMediaSupport *pMediaSupport;
    VARIANT_BOOL    bSupport;

    pAddress->QueryInterface( IID_ITMediaSupport, (void **)&pMediaSupport );

    // does it support VideoIn?
    pMediaSupport->QueryMediaType(
                                  gbstrVideoIn,
                                  &bSupport
                                 );

    if (bSupport)
    {
        // get the mediaterminal for VideoIn
        hr = GetVideoInMediaTerminal(
                                     pAddress,
                                     &ppMediaTerminals[count]
                                    );

        if (S_OK == hr)
        {
            count ++;
        }

        // does it also support VideoOut?
        pMediaSupport->QueryMediaType(
            gbstrVideoOut,
            &bSupport
            );

        if (bSupport)
        {
            // get the mediaterminal for Videoout
            hr = GetMediaTerminal(
                                  pAddress,
                                  gbstrVideoOut,
                                  &ppMediaTerminals[count]
                                 );

            if (S_OK == hr)
            {
                count ++;
            }
        }
    }

    pMediaSupport->Release();

    *pNumMediaTerminals = count;

    return S_OK;
}

/////////////////////////////////////////////////////////////////
// CreateMediaTerminalSafeArray
//
/////////////////////////////////////////////////////////////////
SAFEARRAY *
CreateMediaTerminalSafeArray(
                             ITMediaTerminal ** ppMediaTerminals,
                             LONG nNumMediaTerminals
                            )
{
    SAFEARRAY *             psa;
    SAFEARRAYBOUND          sabound[1];

    // create a safearray with two elements
    // to pass the mediaterminals to tapi
    sabound[0].lLbound = 0;
    sabound[0].cElements = nNumMediaTerminals;

    psa = SafeArrayCreate(
                          VT_UNKNOWN,
                          1,
                          sabound
                         );

    if (NULL != psa)
    {
        // save them in the safearray
        for (long i = 0; i < nNumMediaTerminals; i ++)
        {
            SafeArrayPutElement(
                            psa,
                            &i,
                            ppMediaTerminals[i]
                           );
        }
    }
    return psa;
}

/////////////////////////////////////////////////////////////////
// ReleaseMediaTerminals
//
/////////////////////////////////////////////////////////////////
void
ReleaseMediaTerminals(
                      ITMediaTerminal ** ppMediaTerminals,
                      LONG nNumMediaTerminals
                     )
{
    for (long i = 0; i < nNumMediaTerminals; i ++)
    {
        if (ppMediaTerminals[i])
        {
            ppMediaTerminals[i]->Release();
        }
    }
}

/////////////////////////////////////////////////////////////////////
// Answer the call
/////////////////////////////////////////////////////////////////////
HRESULT
AnswerTheCall()
{
    HRESULT                 hr;
    ITCallInfo *            pCallInfo;
    ITAddress *             pAddress;
    ITMediaTerminal *       ppMediaTerminals[MAXTERMINALS];
    long                    nNumMediaTerminals = MAXTERMINALS;
    SAFEARRAY *             psa;



    if (NULL == gpCall)
    {
        return E_UNEXPECTED;
    }


    // get the address object of this call
    gpCall->QueryInterface( IID_ITCallInfo, (void**)&pCallInfo );
    pCallInfo->get_Address( &pAddress );
    pCallInfo->Release();


    // create the media terminals for this call
    hr = CreateMediaTerminals(
        pAddress,
        ppMediaTerminals,
        &nNumMediaTerminals
        );


    // release the address
    pAddress->Release();


    if (S_OK != hr)
    {
        gpCall->Release();
        gpCall = NULL;
        return hr;
    }

    psa = CreateMediaTerminalSafeArray(ppMediaTerminals, nNumMediaTerminals);

    if (S_OK != hr)
    {
        gpCall->Release();
        gpCall = NULL;
        ReleaseMediaTerminals(ppMediaTerminals, nNumMediaTerminals);
        return hr;
    }

    // put the safearray in a variant
    VARIANT                 var;
    VariantInit(&var);
    var.vt = VT_ARRAY;
    var.parray = psa;

    // call SelectMediaTerminals
    hr = gpCall->SelectMediaTerminals(
                                      var
                                     );

    ReleaseMediaTerminals(ppMediaTerminals, nNumMediaTerminals);

    SafeArrayDestroy( psa );

    if (S_OK != hr)
    {
        gpCall->Release();
        gpCall = NULL;
        return hr;
    }

    // answer the call
    hr = gpCall->Answer();

    return hr;
}

//////////////////////////////////////////////////////////////////////
// DisconnectTheCall
//
// Disconnects the call
//////////////////////////////////////////////////////////////////////
HRESULT
DisconnectTheCall()
{
    HRESULT         hr = S_OK;

    if (NULL != gpCall)
    {
        hr = gpCall->Disconnect( DC_NORMAL );

        gpCall->Release();
        gpCall = NULL;

        return hr;
    }

    return S_FALSE;
}

//////////////////////////////////////////////////////////////////////
// ReleaseTheCall
//
// Releases the call
//////////////////////////////////////////////////////////////////////
void
ReleaseTheCall()
{
    if (NULL != gpCall)
    {
        gpCall->Release();
        gpCall = NULL;
    }
}


///////////////////////////////////////////////////////////////////
//
// HELPER FUNCTIONS
//
///////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////
// DoMessage
///////////////////////////////////////////////////////////////////
void
DoMessage(
          LPWSTR pszMessage
         )
{
    MessageBox(
               ghDlg,
               pszMessage,
               gszTapi30,
               MB_OK
              );
}


//////////////////////////////////////////////////////////////////
// SetStatusMessage
//////////////////////////////////////////////////////////////////
void
SetStatusMessage(
                 LPWSTR pszMessage
                )
{
    SetDlgItemText(
                   ghDlg,
                   IDC_STATUS,
                   pszMessage
                  );
}

///////////////////////////////////////////////////////////////
// EnableButton
//
// Enable, make default, and setfocus to a button
///////////////////////////////////////////////////////////////
void
EnableButton(
             int ID
            )
{
    SendDlgItemMessage(
                       ghDlg,
                       ID,
                       BM_SETSTYLE,
                       BS_DEFPUSHBUTTON,
                       0
                      );
    EnableWindow(
                 GetDlgItem( ghDlg, ID ),
                 TRUE
                );
    SetFocus(
             GetDlgItem( ghDlg, ID )
            );
}

//////////////////////////////////////////////////////////////
// DisableButton
//
// Disable a button
//////////////////////////////////////////////////////////////
void
DisableButton(
              int ID
             )
{
    SendDlgItemMessage(
                       ghDlg,
                       ID,
                       BM_SETSTYLE,
                       BS_PUSHBUTTON,
                       0
                      );
    EnableWindow(
                 GetDlgItem( ghDlg, ID ),
                 FALSE
                );
}