dial.cpp

根据微软提供的例子自己做的一个通过WIN CE平台的TAPI拨打电话的示例程序

				LPTR, 
				sizeof (LINEINFO) * g_dwNumDevs)))
			{
				break;
			}

			// Assume we just add a new line, the lines are sequential and
			// the new line is the last one.
			for (dwLineID = 0; dwLineID < dwParam1; ++dwLineID)
			{
				lpLineInfo[dwLineID] = g_lpLineInfo[dwLineID];
			}

			// Get the new line information.
			GetLineInfo (dwParam1, &lpLineInfo[dwParam1]);

			LocalFree (g_lpLineInfo);
			g_lpLineInfo = lpLineInfo; 
		}
		break;

	case LINE_CLOSE:
		if (g_CurrentLineInfo.hLine == (HLINE) hDevice)
		{
			lpszStatus = TEXT("Closing line");
			if (g_hwndDial)
				MessageBox(g_hwndMain,L"Closing line", L"Message",MB_OK);


			CurrentLineClose ();

			if (g_hwndDial)
				SendMessage (g_hwndDial, WM_COMMAND, MAKEWPARAM(IDOK,0), 0);
		}
		break;

	case LINE_ADDRESSSTATE:
	case LINE_CALLINFO:
	case LINE_DEVSPECIFIC:
	case LINE_DEVSPECIFICFEATURE:
	case LINE_GATHERDIGITS:
	case LINE_GENERATE:
	case LINE_MONITORDIGITS:
	case LINE_MONITORMEDIA:
	case LINE_MONITORTONE:
	case LINE_REMOVE:
	case LINE_REQUEST:
	default:
		break;
	}

}

/***********************************************************************

FUNCTION: 
GetLineInfo 

PURPOSE:
Get line information for selected line.

***********************************************************************/
DWORD GetLineInfo(
				  DWORD dwLineID, 
				  LPLINEINFO lpLineInfo
				  )
{
	DWORD dwSize;
	DWORD     dwReturn;
	LPTSTR lpszLineName = NULL; 
	LPLINEDEVCAPS lpLineDevCaps = NULL;

	// Negotiate the API version number. If it fails, return to dwReturn.
	if (dwReturn = lineNegotiateAPIVersion (
		g_hLineApp,                   // TAPI registration handle
		dwLineID,                     // Line device to be queried
		TAPI_VERSION_1_0,             // Least recent API version 
		TAPI_CURRENT_VERSION,         // Most recent API version 
		&(lpLineInfo->dwAPIVersion),  // Negotiated API version 
		NULL))                        // Must be NULL; the provider-
		// specific extension is not 
		// supported on Windows CE
	{
		goto exit;
	}

	dwSize = sizeof (LINEDEVCAPS);

	// Allocate enough memory for lpLineDevCaps.
	do
	{
		if (!(lpLineDevCaps = (LPLINEDEVCAPS) LocalAlloc (LPTR, dwSize)))
		{
			dwReturn = LINEERR_NOMEM;
			goto exit;
		}

		lpLineDevCaps->dwTotalSize = dwSize;

		if (dwReturn = lineGetDevCaps (g_hLineApp,
			dwLineID,
			lpLineInfo->dwAPIVersion,
			0,
			lpLineDevCaps))
		{
			goto exit;
		}

		// Stop if the allocated memory is equal to or greater than the 
		// needed memory.
		if (lpLineDevCaps->dwNeededSize <= lpLineDevCaps->dwTotalSize)
			break;  

		dwSize = lpLineDevCaps->dwNeededSize;
		LocalFree (lpLineDevCaps);
		lpLineDevCaps = NULL;

	} while (TRUE);

	// Store the line information in *lpLineInfo.
	lpLineInfo->dwPermanentLineID = lpLineDevCaps->dwPermanentLineID;
	lpLineInfo->dwNumOfAddress = lpLineDevCaps->dwNumAddresses;
	lpLineInfo->bVoiceLine = 
		(lpLineDevCaps->dwMediaModes & LINEMEDIAMODE_INTERACTIVEVOICE);

	// Allocate memory for lpszLineName.
	if (!(lpszLineName = (LPTSTR) LocalAlloc (LPTR, REASONABLE_BUFFER_SIZE)))
	{
		dwReturn = LINEERR_NOMEM;
		goto exit;
	}  

	// Store the line name in *lpszLineName.
	if (lpLineDevCaps->dwLineNameSize > 0)
	{
		StringCbCopy(
			lpszLineName, 
			REASONABLE_BUFFER_SIZE,
			(LPTSTR)((LPSTR)lpLineDevCaps + lpLineDevCaps->dwLineNameOffset));
	}
	else 
	{
		_stprintf (lpszLineName, TEXT("Line %d"), dwLineID);
	}

	// Copy lpszLineName to lpLineInfo->lpszLineName.
	lstrcpy (lpLineInfo->szLineName, lpszLineName);

	dwReturn = ERR_NONE;

exit:

	if (lpLineDevCaps)
		LocalFree (lpLineDevCaps);

	if (lpszLineName)
		LocalFree (lpszLineName);

	return dwReturn; 
}

// ***************************************************************************
// Function Name: GetExTAPIInfo
//
// Purpose: To get and display general ExTAPI information.
//
// Arguments: None
//
// Return Values: 
//  TRUE if all ExTAPI operations completed successfully, FALSE otherwise
//
// Description:
//  This function initializes ExTAPI and then calls lineGetGeneralInfo.
//  It then takes the info that lGGI returned and displays it in a MessageBox

BOOL GetExTAPIInfo()
{
	DWORD dwNumDevs;
	DWORD dwAPIVersion = TAPI_API_HIGH_VERSION;
	LINEINITIALIZEEXPARAMS liep;
	HLINEAPP hLineApp = 0;
	HLINE hLine = 0;
	DWORD dwExtVersion;
	TCHAR szMBString[HUGE_BUFFER];
	BOOL bRetVal = FALSE;
	LPBYTE pLineGeneralInfoBytes = NULL;
	DWORD dwTAPILineDeviceID;
	const DWORD dwMediaMode = LINEMEDIAMODE_DATAMODEM | LINEMEDIAMODE_INTERACTIVEVOICE;
	LINEGENERALINFO lviGeneralInfo;
	LPLINEGENERALINFO plviGeneralInfo;
	LPTSTR tsManufacturer, tsModel, tsRevision, tsSerialNumber, tsSubscriberNumber;
	TCHAR szUnavailable[160]; 

	// Load text from STRINGTABLE
	LoadString(g_hInst, IDS_UNAVAILABLE, szUnavailable, ARRAY_LENGTH(szUnavailable)); 

	// set the line init params
	liep.dwTotalSize = sizeof(liep);
	liep.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT;

	if (lineInitializeEx(&hLineApp, 0, 0, gszFriendlyAppName, 
		&dwNumDevs, &dwAPIVersion, &liep)) 
	{
		goto cleanup;
	}

	// get the device ID
	dwTAPILineDeviceID = GetTSPLineDeviceID(hLineApp, dwNumDevs, 
		TAPI_API_LOW_VERSION, 
		TAPI_API_HIGH_VERSION, 
		CELLTSP_LINENAME_STRING);

	// error getting the line device ID?
	if (0xffffffff == dwTAPILineDeviceID) 
	{
		goto cleanup;
	}

	// now try and open the line
	if(lineOpen(hLineApp, dwTAPILineDeviceID, 
		&hLine, dwAPIVersion, 0, 0, 
		LINECALLPRIVILEGE_OWNER, dwMediaMode, 0)) 
	{
		goto cleanup;
	}

	// set up ExTAPI
	if (lineNegotiateExtVersion(hLineApp, dwTAPILineDeviceID, 
		dwAPIVersion, EXT_API_LOW_VERSION, 
		EXT_API_HIGH_VERSION, &dwExtVersion)) 
	{
		goto cleanup;
	}

	// try to get the general info
	lviGeneralInfo.dwTotalSize = sizeof(lviGeneralInfo);

	// step 1: find out how much space we need
	if (lineGetGeneralInfo(hLine, &lviGeneralInfo)) 
	{
		goto cleanup;
	}
	

	// step 2: malloc space for all the info we need
	pLineGeneralInfoBytes = new BYTE[lviGeneralInfo.dwNeededSize];
	plviGeneralInfo = (LPLINEGENERALINFO)pLineGeneralInfoBytes;

	// step 3: call lGGI again with the appropriately sized buffer
	if(NULL != pLineGeneralInfoBytes) 
	{
		plviGeneralInfo->dwTotalSize = lviGeneralInfo.dwNeededSize;
		if (lineGetGeneralInfo(hLine, plviGeneralInfo)) 
		{
			goto cleanup;
		}
	} else 
	{
		goto cleanup;
	}

	// step 4: cast all the arguments to strings
	if(0 < plviGeneralInfo->dwManufacturerSize)
	{ 
		tsManufacturer = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwManufacturerOffset);
	}
	else
	{
		tsManufacturer = szUnavailable;
	}

	if(0 < plviGeneralInfo->dwModelSize)
	{ 
		tsModel = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwModelOffset);
	}
	else
	{
		tsModel = szUnavailable;
	}

	if(0 < plviGeneralInfo->dwRevisionSize)
	{
		tsRevision = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwRevisionOffset);
	}
	else
	{
		tsRevision = szUnavailable;
	}

	if(0 < plviGeneralInfo->dwSerialNumberSize)
	{
		tsSerialNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSerialNumberOffset);
	}
	else
	{
		tsSerialNumber = szUnavailable;
	}

	if(0 < plviGeneralInfo->dwSubscriberNumberSize)
	{
		tsSubscriberNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSubscriberNumberOffset);
	}
	else
	{
		tsSubscriberNumber = szUnavailable;
	}
	// create the message box string.
	// 
	{
		/*
		TCHAR szManufacturer[80]; 
		TCHAR szModel[80]; 
		TCHAR szRevision[80];
		TCHAR szSerialNumber[80];
		TCHAR szSubscriberNumber[80];

		

		LoadString(g_hInstance, IDS_MANUFACTURER, szManufacturer, ARRAY_LENGTH(szManufacturer)); 
		LoadString(g_hInstance, IDS_MODEL, szModel, ARRAY_LENGTH(szModel)); 
		LoadString(g_hInstance, IDS_REVISION, szRevision, ARRAY_LENGTH(szRevision)); 
		LoadString(g_hInstance, IDS_SERIALNUMBER, szSerialNumber, ARRAY_LENGTH(szSerialNumber)); 
		LoadString(g_hInstance, IDS_SUBSCRIBERNUMBER, szSubscriberNumber, ARRAY_LENGTH(szSubscriberNumber)); 
		

		_sntprintf(szMBString, ARRAY_LENGTH(szMBString),
			TEXT("%s: %s\n%s: %s\n%s: %s\n%s: %s\n%s: %s\n"),
			szManufacturer, tsManufacturer, 
			szModel, tsModel, 
			szRevision, tsRevision, 
			szSerialNumber, tsSerialNumber, 
			szSubscriberNumber, tsSubscriberNumber);
		*/
	}
	// pop up the message box
	{
		TCHAR szExTapiLineInfo[80];
		/*
		LoadString(g_hInstance, IDS_EXTAPILINEINFO, szExTapiLineInfo, ARRAY_LENGTH(szExTapiLineInfo)); 
		*/
		MessageBox(NULL, szMBString, szExTapiLineInfo, MB_OK | MB_ICONINFORMATION);
	}

	bRetVal = TRUE;


cleanup:
	if (pLineGeneralInfoBytes) delete [] pLineGeneralInfoBytes;
	if (hLine) lineClose(hLine);
	if (hLineApp) lineShutdown(hLineApp);

	return bRetVal;
}


DWORD GetTSPLineDeviceID(const HLINEAPP hLineApp, 
						 const DWORD dwNumberDevices, 
						 const DWORD dwAPIVersionLow, 
						 const DWORD dwAPIVersionHigh, 
						 const TCHAR* const psTSPLineName)
{
	DWORD dwReturn = 0xffffffff;
	for(DWORD dwCurrentDevID = 0 ; dwCurrentDevID < dwNumberDevices ; dwCurrentDevID++)
	{
		DWORD dwAPIVersion;
		LINEEXTENSIONID LineExtensionID;
		if(0 == lineNegotiateAPIVersion(hLineApp, dwCurrentDevID, 
			dwAPIVersionLow, dwAPIVersionHigh, 
			&dwAPIVersion, &LineExtensionID)) 
		{
			LINEDEVCAPS LineDevCaps;
			LineDevCaps.dwTotalSize = sizeof(LineDevCaps);
			if(0 == lineGetDevCaps(hLineApp, dwCurrentDevID, 
				dwAPIVersion, 0, &LineDevCaps)) 
			{
				BYTE* pLineDevCapsBytes = new BYTE[LineDevCaps.dwNeededSize];
				if(0 != pLineDevCapsBytes) 
				{
					LINEDEVCAPS* pLineDevCaps = (LINEDEVCAPS*)pLineDevCapsBytes;
					pLineDevCaps->dwTotalSize = LineDevCaps.dwNeededSize;
					if(0 == lineGetDevCaps(hLineApp, dwCurrentDevID, 
						dwAPIVersion, 0, pLineDevCaps)) 
					{
						if(0 == _tcscmp((TCHAR*)((BYTE*)pLineDevCaps+pLineDevCaps->dwLineNameOffset), 
							psTSPLineName)) 
						{
							dwReturn = dwCurrentDevID;
						}
					}
					delete[]  pLineDevCapsBytes;
				}
			}
		}
	}
	return dwReturn;
}