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

C/C++ Source or Header | 1997-09-09 | 25.5 KB | 1,053 lines

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

//////////////////////////////////////////////////////////
// T3OUT.EXE
//
// Example of making an outgoing call with TAPI 3.0
//
// This application will allow a user to make a call
// by using TAPI 3.0.  The application will simply look
// for the first TAPI line that support Audio, and can
// dial a phone number.  It will then use that line to
// make calls.
//
// This application does not handle incoming calls, and
// does not process incoming messages.
//
//////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////
// Constants
//////////////////////////////////////////////////////////

const DWORD ADDRESSLENGTH   = 128;
const DWORD MAXTERMINALS    = 5;

const WCHAR * const gszTapi30           = L"TAPI 3.0 Outgoing Call Sample";

const WCHAR * const gszConferenceName   = L"Conference Name";
const WCHAR * const gszEmailName        = L"Email Name";
const WCHAR * const gszMachineName      = L"Machine Name";
const WCHAR * const gszPhoneNumber      = L"Phone Number";
const WCHAR * const gszIPAddress        = L"IP Address";

//////////////////////////////////////////////////////////
// GLOBALS
//////////////////////////////////////////////////////////
HINSTANCE               ghInst;
HWND                    ghDlg = NULL;
ITTAPI *                gpTapi;
ITAddress *             gpAddress;
ITBasicCallControl *    gpCall;

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


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

HRESULT
FindAnAddress(
              DWORD dwAddressType
             );

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

HRESULT
GetVideoInMediaTerminal(
                 ITMediaTerminal ** ppMediaTerminal
                );

HRESULT
MakeTheCall(
            DWORD dwAddressType,
            PWCHAR szAddressToCall
           );

HRESULT
DisconnectTheCall();

void
DoMessage(
          LPWSTR pszMessage
         );

HRESULT
InitializeTapi();

void
ShutdownTapi();

void
EnableButton(
             HWND hDlg,
             int ID
            );
void
DisableButton(
              HWND hDlg,
              int ID
             );

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


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

    if (S_OK != InitializeTapi())
    {
        return 0;
    }

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


    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 );

    return S_OK;
}


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

    // if we have an address object
    // release it
    if (NULL != gpAddress)
    {
        gpAddress->Release();
    }

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

    SysFreeString( gbstrAudioIn );
    SysFreeString( gbstrAudioOut );
    SysFreeString( gbstrVideoIn );
    SysFreeString( gbstrVideoOut );
}

///////////////////////////////////////////////////////////////////////////
// InitAddressTypeComboBox
//
// Put address type string in the combo box
// and save the addresstype with the string
//
///////////////////////////////////////////////////////////////////////////
void
InitAddressTypeComboBox(
    HWND hComboBox
    )
{
    int i;

    i = SendMessage( hComboBox, CB_ADDSTRING, 0, (long)gszConferenceName );

    SendMessage(
                hComboBox,
                CB_SETITEMDATA ,
                i,
                (long)T3_ADDRESSTYPE_CONFERENCENAME
               );


    i = SendMessage( hComboBox, CB_ADDSTRING, 0, (long)gszEmailName );

    SendMessage(
                hComboBox,
                CB_SETITEMDATA ,
                i,
                (long)T3_ADDRESSTYPE_EMAILNAME
               );


    i = SendMessage( hComboBox, CB_ADDSTRING, 0, (long)gszMachineName );

    SendMessage(
                hComboBox,
                CB_SETITEMDATA ,
                i,
                (long)T3_ADDRESSTYPE_DOMAINNAME
               );


    i = SendMessage( hComboBox, CB_ADDSTRING, 0, (long)gszPhoneNumber );

    SendMessage(
                hComboBox,
                CB_SETITEMDATA ,
                i,
                (long)T3_ADDRESSTYPE_PHONENUMBER
               );


    SendMessage( hComboBox, CB_SETCURSEL, i, 0 );

    i = SendMessage( hComboBox, CB_ADDSTRING, 0, (long)gszIPAddress );

    SendMessage(
                hComboBox,
                CB_SETITEMDATA ,
                i,
                (long)T3_ADDRESSTYPE_IPADDRESS
               );

}

///////////////////////////////////////////////////////////////////////////
// MainDlgProc
///////////////////////////////////////////////////////////////////////////
BOOL
CALLBACK
MainDialogProc(
               HWND hDlg,
               UINT uMsg,
               WPARAM wParam,
               LPARAM lParam
              )
{
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            HWND hComboBox;


            // set up dialog
            ghDlg = hDlg;

            EnableButton( hDlg, IDOK );
            DisableButton( hDlg, IDC_DISCONNECT );

            hComboBox = GetDlgItem( hDlg, IDC_ADDRESSTYPE );

            InitAddressTypeComboBox(hComboBox);

            SetFocus( hComboBox );

            return 0;
        }

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

                return 1;
            }

            // dial request
            if ( LOWORD(wParam) == IDOK )
            {
                HWND hComboBox;
                DWORD dwIndex;
                DWORD dwAddressType;
                WCHAR szAddressToCall[ADDRESSLENGTH];


                // get the address type the user selected.
                hComboBox = GetDlgItem( hDlg, IDC_ADDRESSTYPE );
                dwIndex = SendMessage( hComboBox, CB_GETCURSEL, 0, 0 );

                dwAddressType = SendMessage(
                                             hComboBox,
                                             CB_GETITEMDATA,
                                             dwIndex,
                                             0
                                           );

                // get the address the user wants to call
                GetDlgItemText(
                               hDlg,
                               IDC_ADDRESS,
                               szAddressToCall,
                               ADDRESSLENGTH
                              );

                // make the call
                if ( S_OK == MakeTheCall(dwAddressType, szAddressToCall) )
                {
                    EnableButton( hDlg, IDC_DISCONNECT );
                    DisableButton( hDlg, IDOK );
                }
                else
                {
                    DoMessage(L"The call failed to connect");
                }

                return 1;
            }

            // disconnect requestion
            if ( LOWORD( wParam ) == IDC_DISCONNECT )
            {
                // disconnect
                if (S_OK == DisconnectTheCall())
                {
                    EnableButton( hDlg, IDOK );
                    DisableButton( hDlg, IDC_DISCONNECT );
                }
                else
                {
                    DoMessage(L"The call failed to disconnect");
                }

                return 1;
            }

            return 0;
        }
        default:

            return 0;
    }
}


////////////////////////////////////////////////////////////////////////
// FindAnAddress
//
// Finds an address object that this application will use to make calls on.
//
// This function finds an address that supports the addresstype passed
// in, as well as the audioin and audioout media types.
//
// Return Value
//          S_OK if it finds an address
//          S_FALSE if it does not find an address
////////////////////////////////////////////////////////////////////////
HRESULT
FindAnAddress(
              DWORD dwAddressType
             )
{
    HRESULT             hr = S_OK;
    BOOL                bFoundAddress = FALSE;
    IEnumAddress *      pEnumAddress;
    ITAddress *         pAddress;
    IEnumAddressType *  pEnumAddressTypes;
    DWORD               dwType;

    // if we have an address object
    // release it
    if (NULL != gpAddress)
    {
        gpAddress->Release();
        gpAddress = NULL;
    }

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

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

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

        if (S_OK != hr)
        {
            break;
        }

        // enumerate the address types that
        // this address supports
        hr = pAddress->_EnumerateAddressType( &pEnumAddressTypes );

        if (S_OK != hr)
        {
            pAddress->Release();

            continue;
        }

        while (TRUE)
        {
            ITMediaSupport * pMediaSupport;
            VARIANT_BOOL     bSupport;

            // get the next address type
            hr = pEnumAddressTypes->Next( 1, &dwType, NULL );

            if (S_OK != hr)
            {
                break;
            }

            // is the type we are looking for?
            if ( dwAddressType == dwType )
            {
                // yes
                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)
                    {
                        // save
                        pMediaSupport->Release();

                        gpAddress = pAddress;
                        gpAddress->AddRef();

                        bFoundAddress = TRUE;
                        break;
                    }
                }

                pMediaSupport->Release();
            }
        }

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

    pEnumAddress->Release();

    if (!bFoundAddress)
    {
        return S_FALSE;
    }

    return S_OK;
}


/////////////////////////////////////////////////////////////////
// CreateMediaTerminals
//
// Create audioin and audioout terminals.
//
// If the address also supports video, create
// Videoin and videoout terminals, too.
//
// This function assumes that ppMediaTerminals has a size no less than four.
/////////////////////////////////////////////////////////////////
HRESULT
CreateMediaTerminals(
                     ITMediaTerminal ** ppMediaTerminals,
                     PLONG pNumMediaTerminals
                    )
{
    int count = 0;
    HRESULT hr;

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

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

    count ++;

    // get the mediaterminal for audioout
    hr = GetMediaTerminal(
                          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;

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

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

    if (bSupport)
    {
        // get the mediaterminal for VideoIn
        hr = GetVideoInMediaTerminal(
                                  &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(
                                  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();
        }
    }
}

/////////////////////////////////////////////////////////////////
// MakeTheCall
//
// Sets up and makes a call
/////////////////////////////////////////////////////////////////
HRESULT
MakeTheCall(
            DWORD dwAddressType,
            PWCHAR szAddressToCall
           )
{
    HRESULT                 hr = S_OK;
    ITMediaTerminal *       ppMediaTerminals[MAXTERMINALS];
    long                    nNumMediaTerminals = MAXTERMINALS;
    SAFEARRAY *             psa;
    VARIANT                 var;
    BSTR                    bstrAddressToCall;

    // find an address object that
    // we will use to make calls on
    hr = FindAnAddress(dwAddressType);

    if (S_OK != hr)
    {
        DoMessage(L"Could not find an address to make a phone call on");

        return hr;
    }

    bstrAddressToCall = SysAllocString( szAddressToCall );

    hr = gpAddress->CreateCall( bstrAddressToCall, &gpCall );

    SysFreeString ( bstrAddressToCall );

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

    hr = CreateMediaTerminals(ppMediaTerminals, &nNumMediaTerminals);

    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
    VariantInit(&var);
    var.vt = VT_ARRAY;
    var.parray = psa;

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

    ReleaseMediaTerminals(ppMediaTerminals, nNumMediaTerminals);

    SafeArrayDestroy( psa );

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

    // We're now ready to call connect.
    //
    // the TRUE parameter indicates that this
    // call is sychronous - that is, it won't
    // return until the call is in the connected
    // state (or fails to connect)
    // Since this is called in the UI thread,
    // this means that the app will appear
    // to hang until this function returns.
    // Some TAPI service providers may take a long
    // time for a call to reach the connected state.
    hr = gpCall->Connect( TRUE );

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

    return hr;
}


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

    // get the terminal support interface
    gpAddress->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(
                 ITMediaTerminal ** ppMediaTerminal
                )
{
    HRESULT             hr = S_OK;
    ITTerminalSupport * pTerminalSupport;
    ITTerminal *        pTerminal;

    // get the terminal support interface
    gpAddress->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;

}


//////////////////////////////////////////////////////////////////////
// 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;
}



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


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

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

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