extapidlg.cpp

TAPI用法的示例

// ExTapiDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ExTapiApp.h"
#include "ExTapiDlg.h"

#include <tapi.h>
#include <extapi.h>
#include <tsp.h>
#include "resource.h"

#define TAPI_API_LOW_VERSION    0x00010003
#define TAPI_CURRENT_VERSION	0x00020000
#define EXT_API_LOW_VERSION     0x00010000
#define EXT_API_HIGH_VERSION    0x00010000

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CExTapiDlg dialog

CExTapiDlg::CExTapiDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CExTapiDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CExTapiDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

    m_dwAPIVersion = TAPI_CURRENT_VERSION;
    m_hLineApp = 0;
    m_hLine = 0;
    m_dwExtVersion = 0;
}

void CExTapiDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CExTapiDlg)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CExTapiDlg, CDialog)
	//{{AFX_MSG_MAP(CExTapiDlg)
	ON_BN_CLICKED(IDC_BUTTON1, OnGetSystemType)
	ON_BN_CLICKED(IDC_BUTTON2, OnGetBarringInfo)
	ON_BN_CLICKED(IDC_BUTTON3, OnGetAddressID)
	ON_BN_CLICKED(IDC_BUTTON4, OnGetHCSCD)
	ON_BN_CLICKED(IDC_BUTTON5, OnGetCurrentOperator)
	ON_BN_CLICKED(IDC_BUTTON6, OnGetEquipmentState)
	ON_BN_CLICKED(IDC_BUTTON7, OnGetGeneralInfo)
	ON_BN_CLICKED(IDC_BUTTON8, OnGetAvailOps)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CExTapiDlg message handlers

BOOL CExTapiDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	CenterWindow(GetDesktopWindow());	// center to the hpc screen

    // set the line init params
    LINEINITIALIZEEXPARAMS LineExtParams;
    LineExtParams.dwTotalSize = sizeof(LineExtParams);
    LineExtParams.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT;
    
    if (::lineInitializeEx(&m_hLineApp, 0, 0, _T("Developer.com Test"), 
                         &m_dwNumDevs, &m_dwAPIVersion, &LineExtParams)) 
    {
		EndDialog(IDOK);
		return FALSE;
    }

	m_dwTSPILineDeviceID = GetTSPLineDeviceID(CELLTSP_LINENAME_STRING);
//	m_dwTSPILineDeviceID = GetTSPLineDeviceID(L"GPRS Modem - Data Port as COM7:");
	if ( m_dwTSPILineDeviceID == (DWORD)-1 )
	{
		::lineShutdown(m_hLineApp);
		EndDialog(IDOK);
		return FALSE;
	}

    // open the line
    if( ::lineOpen(m_hLineApp, m_dwTSPILineDeviceID, 
                &m_hLine, m_dwAPIVersion, 0, 0, 
                LINECALLPRIVILEGE_OWNER, LINEMEDIAMODE_DATAMODEM, 0) ) 
    {
		::lineShutdown(m_hLineApp);
		EndDialog(IDOK);
		return FALSE;
    }

    // set up ExTAPI
    if ( ::lineNegotiateExtVersion(m_hLineApp, m_dwTSPILineDeviceID, 
                                m_dwAPIVersion, EXT_API_LOW_VERSION, 
                                EXT_API_HIGH_VERSION, &m_dwExtVersion) ) 
    {
		::lineClose(m_hLine);
		::lineShutdown(m_hLineApp);
		EndDialog(IDOK);
		return FALSE;
    }

	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

DWORD CExTapiDlg::GetTSPLineDeviceID(const TCHAR* const psTSPLineName)
{
    DWORD dwReturn = -1;
    for(DWORD dwCurrentDevID = 0 ; dwCurrentDevID < m_dwNumDevs ; dwCurrentDevID++)
    {
        LINEEXTENSIONID LineExtensionID;
        if( ::lineNegotiateAPIVersion(m_hLineApp, dwCurrentDevID, 
                                        TAPI_API_LOW_VERSION, TAPI_CURRENT_VERSION, 
                                        &m_dwAPIVersion, &LineExtensionID) == 0 ) 
        {
            LINEDEVCAPS LineDevCaps;
            LineDevCaps.dwTotalSize = sizeof(LineDevCaps);
            if( ::lineGetDevCaps(m_hLineApp, dwCurrentDevID, 
                                   m_dwAPIVersion, 0, &LineDevCaps) == 0 ) 
            {
                BYTE* pLineDevCapsBytes = new BYTE[LineDevCaps.dwNeededSize];
                if(0 != pLineDevCapsBytes) 
                {
                    LINEDEVCAPS* pLineDevCaps = (LINEDEVCAPS*)pLineDevCapsBytes;
                    pLineDevCaps->dwTotalSize = LineDevCaps.dwNeededSize;
                    if( ::lineGetDevCaps(m_hLineApp, dwCurrentDevID, 
                                           m_dwAPIVersion, 0, pLineDevCaps) == 0 ) 
                    {
                        if(0 == _tcscmp((TCHAR*)((BYTE*)pLineDevCaps+pLineDevCaps->dwLineNameOffset), 
                                        psTSPLineName)) 
                        {
                            dwReturn = dwCurrentDevID;
                        }
                    }
                    delete[]  pLineDevCapsBytes;
                }
			}
		}
    }
    return dwReturn;
}

void CExTapiDlg::GetTAPIErrorMsg(TCHAR *szMsg,int nSize, DWORD dwError)
{
	LPTSTR lpBuffer = 0;
	DWORD dwRet = 0;
	
	dwRet = ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
		NULL,TAPIERROR_FORMATMESSAGE(dwError),MAKELANGID(LANG_NEUTRAL, LANG_NEUTRAL),
		(LPTSTR) &lpBuffer,0,NULL);
	memset(szMsg,0,nSize);
	if (lpBuffer && dwRet)
	{
		_tcscpy(szMsg,lpBuffer);
		LocalFree(lpBuffer);
	}
	else
	{
		_stprintf(szMsg,L"Unknown Error: 0x%X",dwError);
	}
}

#include <math.h>
void CExTapiDlg::OnGetSystemType() 
{
	struct LineSysTypes 
	{ 
		DWORD dwType; 
		TCHAR* szDesc;
	}
	Types[] = 
	{
		{LINESYSTEMTYPE_NONE,L"NONE"},
		{LINESYSTEMTYPE_IS95A,L"IS95A"},
		{LINESYSTEMTYPE_IS95B,L"IS95B"},
		{LINESYSTEMTYPE_1XRTTPACKET,L"1XRTTPACKET"},
		{LINESYSTEMTYPE_GSM,L"GSM"},
		{LINESYSTEMTYPE_GPRS,L"GPRS"}
	};

	DWORD dwCurrentSystemType;
	HRESULT hr = ::lineGetCurrentSystemType(m_hLine,&dwCurrentSystemType);
	if ( SUCCEEDED(hr) )
	{
		CString sInfo(L"Current System Type is ");
		switch (dwCurrentSystemType)
		{
		case LINESYSTEMTYPE_NONE:
			sInfo += L"NONE";
			break;
		case LINESYSTEMTYPE_IS95A:
			sInfo += L"IS95A";
			break;
		case LINESYSTEMTYPE_IS95B:
			sInfo += L"IS95B";
			break;
		case LINESYSTEMTYPE_1XRTTPACKET:
			sInfo += L"1XRTTPACKET";
			break;
		case LINESYSTEMTYPE_GSM:
			sInfo += L"GSM";
			break;
		case LINESYSTEMTYPE_GPRS:
			sInfo += L"GPRS";
			break;
		}
 		AfxMessageBox(sInfo);
	}
}

void CExTapiDlg::OnGetBarringInfo() 
{
	DWORD dwModes = 0;
	DWORD dwClasses = 0;
	LONG lRes = ::lineGetCallBarringCaps(m_hLine,&dwModes,&dwClasses);
	if ( lRes == 0 )
	{
		CString sInfo(L"Current Barring Modes are \r\n");
		if (dwModes	& LINEBARRMODE_OUT)
			sInfo += L"OUT\r\n";
		if (dwModes	& LINEBARRMODE_OUT_INT)
			sInfo += L"INT\r\n";
		if (dwModes	& LINEBARRMODE_OUT_INTEXTOHOME)
			sInfo += L"OUT_INTEXTOHOME\r\n";
		if (dwModes	& LINEBARRMODE_IN)
			sInfo += L"IN\r\n";
		if (dwModes	& LINEBARRMODE_IN_ROAM)
			sInfo += L"IN_ROAM\r\n";
		if (dwModes	& LINEBARRMODE_IN_NOTINSIM)
			sInfo += L"IN_NOTINSIM\r\n";
		if (dwModes	& LINEBARRMODE_ALL)
			sInfo += L"ALL\r\n";
		if (dwModes	& LINEBARRMODE_ALL_OUT)
			sInfo += L"ALL_OUT\r\n";
		if (dwModes	& LINEBARRMODE_ALL_IN)
			sInfo += L"ALL_IN";
 		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRes);
		AfxMessageBox(szMsg);
	}

	lRes = lineGetCallWaitingCaps(m_hLine,&dwClasses);
	if ( lRes == 0 )
	{
		CString sInfo;
		sInfo.Format(L"Current Waiting Modes (%X) are \r\n",dwClasses);
		if (dwModes	& LINEBARRMODE_OUT)
			sInfo += L"OUT\r\n";
		if (dwModes	& LINEBARRMODE_OUT_INT)
			sInfo += L"INT\r\n";
		if (dwModes	& LINEBARRMODE_OUT_INTEXTOHOME)
			sInfo += L"OUT_INTEXTOHOME\r\n";
		if (dwModes	& LINEBARRMODE_IN)
			sInfo += L"IN\r\n";
		if (dwModes	& LINEBARRMODE_IN_ROAM)
			sInfo += L"IN_ROAM\r\n";
		if (dwModes	& LINEBARRMODE_IN_NOTINSIM)
			sInfo += L"IN_NOTINSIM\r\n";
		if (dwModes	& LINEBARRMODE_ALL)
			sInfo += L"ALL\r\n";
		if (dwModes	& LINEBARRMODE_ALL_OUT)
			sInfo += L"ALL_OUT\r\n";
		if (dwModes	& LINEBARRMODE_ALL_IN)
			sInfo += L"ALL_IN";
 		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRes);
		AfxMessageBox(szMsg);
	}
}
 

BOOL CExTapiDlg::DestroyWindow() 
{
	if ( m_hLine )
		::lineClose(m_hLine);
	if ( m_hLineApp )
		::lineShutdown(m_hLineApp);
	
	return CDialog::DestroyWindow();
}

void CExTapiDlg::OnGetAddressID() 
{
	DWORD dwAddressID = 0;
	HRESULT hr = ::lineGetCurrentAddressID(m_hLine,&dwAddressID);
	if ( SUCCEEDED(hr) )
	{
		CString sInfo;
		sInfo.Format(L"Current Address ID is %X",dwAddressID);
		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), (DWORD)hr);
		AfxMessageBox(szMsg);
	}
}

void CExTapiDlg::OnGetHCSCD() 
{
	DWORD dwChannelsIn = 0;
	DWORD dwChannelsOut = 0;
	DWORD dwChannelCoding = 0;
	DWORD dwAirInterfaceRate = 0; 
	LONG lRet = ::lineGetCurrentHSCSDStatus(m_hLine, &dwChannelsIn, &dwChannelsOut, &dwChannelCoding, &dwAirInterfaceRate);
	if ( lRet == 0 )
	{
		CString sInfo;
		sInfo.Format(L"Current HSCSD Status is %X/%X/%X/%X",
			dwChannelsIn,
			dwChannelsOut,
			dwChannelCoding,
			dwAirInterfaceRate);
		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRet);
		AfxMessageBox(szMsg);
	}
}

void CExTapiDlg::OnGetCurrentOperator() 
{
	DWORD dwRegisterStatus = 0;
	LONG lStat = lineGetRegisterStatus(m_hLine,&dwRegisterStatus);
	if ( lStat == 0 )
	{
		CString sInfo;
		sInfo.Format(L"Status = %X",dwRegisterStatus);
		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lStat);
		AfxMessageBox(szMsg);
	}

	LINEOPERATOR CurrentOperator;
	LONG lRet = ::lineGetCurrentOperator(m_hLine,&CurrentOperator);
	if ( lRet == 0 )
	{
		CString sInfo;
		sInfo.Format(L"Idx = %d\r\nShort = %s\r\nLong = %s",
			CurrentOperator.dwIndex,
			CurrentOperator.lpszShortName,
			CurrentOperator.lpszLongName);
		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRet);
		AfxMessageBox(szMsg);
	}
}

void CExTapiDlg::OnGetEquipmentState() 
{
	TCHAR *szEqStates[] = 
	{
		L"LINEEQUIPSTATE_MINIMUM",
		L"LINEEQUIPSTATE_RXONLY",
		L"LINEEQUIPSTATE_TXONLY",
		L"LINEEQUIPSTATE_NOTXRX",
		L"LINEEQUIPSTATE_FULL"
	};
	TCHAR *szRadioSupport[] = 
	{
		L"LINERADIOSUPPORT_OFF",
		L"LINERADIOSUPPORT_ON",
		L"LINERADIOSUPPORT_UNKNOWN"
	};

	DWORD dwState = 0;
	DWORD dwRadioSupport = 0;
	LONG lRet = lineGetEquipmentState(m_hLine,&dwState,&dwRadioSupport);
	if ( lRet == 0 )
	{
		CString sInfo;
		sInfo.Format(L"State = %s, Radio = %s",
			szEqStates[dwState - 1],
			szRadioSupport[dwRadioSupport-1]);
		AfxMessageBox(sInfo);
	}
	else
	{
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRet);
		AfxMessageBox(szMsg);
	}
}

void CExTapiDlg::OnGetGeneralInfo() 
{
    LPBYTE pLineGeneralInfoBytes = NULL;
    const DWORD dwMediaMode = LINEMEDIAMODE_DATAMODEM;
    LINEGENERALINFO lviGeneralInfo;
    LPLINEGENERALINFO plviGeneralInfo;
    LPTSTR tsManufacturer, tsModel, tsRevision, tsSerialNumber, tsSubscriberNumber;
	CString sInfo;
	
    lviGeneralInfo.dwTotalSize = sizeof(lviGeneralInfo);
	
    LONG lRes = ::lineGetGeneralInfo(m_hLine, &lviGeneralInfo);
    if (lRes != 0 && lRes != LINEERR_STRUCTURETOOSMALL) 
    {
		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRes);
		AfxMessageBox(szMsg);
		return;
    }
	
    pLineGeneralInfoBytes = new BYTE[lviGeneralInfo.dwNeededSize];
    plviGeneralInfo = (LPLINEGENERALINFO)pLineGeneralInfoBytes;
	
    if(pLineGeneralInfoBytes != NULL) 
    {
        plviGeneralInfo->dwTotalSize = lviGeneralInfo.dwNeededSize;
        if ( (lRes = ::lineGetGeneralInfo(m_hLine, plviGeneralInfo)) != 0 ) 
        {
			TCHAR szMsg[255];
			GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRes);
			AfxMessageBox(szMsg);
        }
		else
		{
			TCHAR szUnavailable[] = L"Unavailable";
			if(plviGeneralInfo->dwManufacturerSize)
			{ 
				tsManufacturer = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwManufacturerOffset);
			}
			else
			{
				tsManufacturer = szUnavailable;
			}
			
			if(plviGeneralInfo->dwModelSize)
			{ 
				tsModel = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwModelOffset);
			}
			else
			{
				tsModel = szUnavailable;
			}
			
			if(plviGeneralInfo->dwRevisionSize)
			{
				tsRevision = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwRevisionOffset);
			}
			else
			{
				tsRevision = szUnavailable;
			}
			
			if(plviGeneralInfo->dwSerialNumberSize)
			{
				tsSerialNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSerialNumberOffset);
			}
			else
			{
				tsSerialNumber = szUnavailable;
			}
			
			if(plviGeneralInfo->dwSubscriberNumberSize)
			{
				tsSubscriberNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSubscriberNumberOffset);
			}
			else
			{
				tsSubscriberNumber = szUnavailable;
			}
			
			sInfo.Format(L"Manufacturer: %s\nModel: %s\nRevision: %s\nSerial No: %s\nSubscriber No: %s\n",
				tsManufacturer, 
				tsModel, 
				tsRevision, 
				tsSerialNumber, 
				tsSubscriberNumber);
			AfxMessageBox(sInfo);
		}
    } 
	
	delete [] pLineGeneralInfoBytes;
}

void CExTapiDlg::OnGetAvailOps() 
{
	LINEOPERATORSTATUS lops;

	lops.dwTotalSize = sizeof(LINEOPERATORSTATUS);

 	BeginWaitCursor();
	LONG lRes = ::lineGetOperatorStatus(m_hLine, &lops);
    if (lRes != 0 && lRes != LINEERR_STRUCTURETOOSMALL) 
    {
		EndWaitCursor();

		TCHAR szMsg[255];
		GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRes);
		AfxMessageBox(szMsg);
		return;
    }
	

	CString sInfo(L"Available Operators:\r\n");
    LPBYTE pLineOperatorStatusBytes = new BYTE[lops.dwNeededSize];
    LPLINEOPERATORSTATUS pStatus = (LPLINEOPERATORSTATUS)pLineOperatorStatusBytes;
	
    if(pLineOperatorStatusBytes != NULL) 
    {
        pStatus->dwTotalSize = lops.dwNeededSize;
        if ( (lRes = ::lineGetOperatorStatus(m_hLine, pStatus)) != 0 ) 
        {
			TCHAR szMsg[255];
			GetTAPIErrorMsg(szMsg,sizeof(szMsg), lRes);
			AfxMessageBox(szMsg);
        }
		else
		{
			LPLINEOPERATOR pOperator = (LPLINEOPERATOR)((LPBYTE)pStatus+(pStatus->dwAvailableOffset));
			for(DWORD dwOperatorNumber = 0;dwOperatorNumber < pStatus->dwAvailableCount; dwOperatorNumber++) 
			{
				sInfo += pOperator->lpszLongName;
				sInfo += L"\r\n";
				pOperator++;
			}
		}
	}

	delete[] pLineOperatorStatusBytes;
	EndWaitCursor();

	AfxMessageBox(sInfo);
}