comdial.c

可以实现最简单的电话呼叫和应答,并可以通过按键来实现接通和挂断

	if (lrc) return lrc;
	lrc=mylineGetAddressStatus();
	if (lrc) return lrc;

	return lrc;
}

//011***************************************************************************************
LONG mylineGetAddressStatus()
{
	LONG lrc;
	DWORD dwsize;

	if (mytapi.bLineAddressStatusAlloced) {
		free(mytapi.pLineAddressStatus);
		mytapi.bLineAddressStatusAlloced=FALSE;
	}
	if (!(mytapi.pLineAddressStatus=(LINEADDRESSSTATUS *)calloc(1,sizeof(LINEADDRESSSTATUS))))
		return LINEERR_NOMEM;
	mytapi.bLineAddressStatusAlloced=TRUE;

	mytapi.pLineAddressStatus->dwTotalSize=sizeof(LINEADDRESSSTATUS);
	for (;;) {
		lrc=lineGetAddressStatus(mytapi.hLine,
				mytapi.dwAddress,mytapi.pLineAddressStatus);
		if (lrc) {
			free(mytapi.pLineAddressStatus);
			mytapi.bLineAddressStatusAlloced=FALSE;
			return lrc;
		}

		dwsize=mytapi.pLineAddressStatus->dwNeededSize;
		if (mytapi.pLineAddressStatus->dwTotalSize<dwsize)
		{
			free(mytapi.pLineAddressStatus);
			mytapi.bLineAddressStatusAlloced=FALSE;
			mytapi.pLineAddressStatus=(LINEADDRESSSTATUS *)calloc(1,dwsize);
			if (!mytapi.pLineAddressStatus) return LINEERR_NOMEM;
			mytapi.bLineAddressStatusAlloced=TRUE;
			mytapi.pLineAddressStatus->dwTotalSize=dwsize;
			continue;
		}
		break;
	}

	return lrc;
}

//012***************************************************************************************
LONG mylineGetLineDevStatus()
{
	LONG lrc;
	DWORD dwsize;

	if (mytapi.bLineDevStatusAlloced) {
		free(mytapi.pLineDevStatus);
		mytapi.bLineDevStatusAlloced=FALSE;
	}
	if (!(mytapi.pLineDevStatus=(LINEDEVSTATUS *)calloc(1,sizeof(LINEDEVSTATUS))))
		return LINEERR_NOMEM;
	mytapi.bLineDevStatusAlloced=TRUE;

	mytapi.pLineDevStatus->dwTotalSize=sizeof(LINEDEVSTATUS);
	for (;;) {
		lrc=lineGetLineDevStatus(mytapi.hLine,mytapi.pLineDevStatus);
		if (lrc) {
			free(mytapi.pLineDevStatus);
			mytapi.bLineDevStatusAlloced=FALSE;
			return lrc;
		}

		dwsize=mytapi.pLineDevStatus->dwNeededSize;
		if (mytapi.pLineDevStatus->dwTotalSize<dwsize)
		{
			free(mytapi.pLineDevStatus);
			mytapi.bLineDevStatusAlloced=FALSE;
			mytapi.pLineDevStatus=(LINEDEVSTATUS *)calloc(1,dwsize);
			if (!mytapi.pLineDevStatus) return LINEERR_NOMEM;
			mytapi.bLineDevStatusAlloced=TRUE;
			mytapi.pLineDevStatus->dwTotalSize=dwsize;
			continue;
		}
		break;
	}

	return lrc;
}

//013***************************************************************************************
LONG mylineGetCallStatus()
{
	LONG lrc;
	DWORD dwsize;

	if (mytapi.bLineCallStatusAlloced) {
		free(mytapi.pLineCallStatus);
		mytapi.bLineCallStatusAlloced=FALSE;
	}
	if (!(mytapi.pLineCallStatus=(LINECALLSTATUS *)calloc(1,sizeof(LINECALLSTATUS))))
		return LINEERR_NOMEM;
	mytapi.bLineCallStatusAlloced=TRUE;

	mytapi.pLineCallStatus->dwTotalSize=sizeof(LINECALLSTATUS);
	for (;;) {
		lrc=lineGetCallStatus(mytapi.hCall,mytapi.pLineCallStatus);
		if (lrc) {
			free(mytapi.pLineCallStatus);
			mytapi.bLineCallStatusAlloced=FALSE;
			return lrc;
		}

		dwsize=mytapi.pLineCallStatus->dwNeededSize;
		if (mytapi.pLineCallStatus->dwTotalSize<dwsize)
		{
			free(mytapi.pLineCallStatus);
			mytapi.bLineCallStatusAlloced=FALSE;
			mytapi.pLineCallStatus=(LINECALLSTATUS *)calloc(1,dwsize);
			if (!mytapi.pLineCallStatus) return LINEERR_NOMEM;
			mytapi.bLineCallStatusAlloced=TRUE;
			mytapi.pLineCallStatus->dwTotalSize=dwsize;
			continue;
		}
		break;
	}

	return lrc;
}

//014***************************************************************************************
LONG mylineGetCallInfo()
{
	LONG lrc;
	DWORD dwsize;

	if (mytapi.bLineCallInfoAlloced) {
		free(mytapi.pLineCallInfo);
		mytapi.bLineCallInfoAlloced=FALSE;
	}
	if (!(mytapi.pLineCallInfo=(LINECALLINFO *)calloc(1,sizeof(LINECALLINFO))))
		return LINEERR_NOMEM;
	mytapi.bLineCallInfoAlloced=TRUE;

	mytapi.pLineCallInfo->dwTotalSize=sizeof(LINECALLINFO);
	for (;;) {
		lrc=lineGetCallInfo(mytapi.hCall,mytapi.pLineCallInfo);
		if (lrc) {
			free(mytapi.pLineCallInfo);
			mytapi.bLineCallInfoAlloced=FALSE;
			return lrc;
		}

		dwsize=mytapi.pLineCallInfo->dwNeededSize;
		if (mytapi.pLineCallInfo->dwTotalSize<dwsize)
		{
			free(mytapi.pLineCallInfo);
			mytapi.bLineCallInfoAlloced=FALSE;
			mytapi.pLineCallInfo=(LINECALLINFO *)calloc(1,dwsize);
			if (!mytapi.pLineCallInfo) return LINEERR_NOMEM;
			mytapi.bLineCallInfoAlloced=TRUE;
			mytapi.pLineCallInfo->dwTotalSize=dwsize;
			continue;
		}
		break;
	}

	return lrc;
}

//015******************************************************************************
void telephonyShutdown()
{
	DWORD id;

	if (mytapi.bLineOpen) lineClose(mytapi.hLine);

	if (mytapi.bOldDevConfigAlloced) 
		lineSetDevConfig(mytapi.dwLine,
			(LPVOID)((LPBYTE)mytapi.pOldDevConfig
				+mytapi.pOldDevConfig->dwStringOffset),
			mytapi.pOldDevConfig->dwStringSize,
			"comm/datamodem");

	if (mytapi.bReading) {
		mytapi.bReading=FALSE;
		while (GetExitCodeThread(mytapi.hThread,&id))
		{
			if (id==STILL_ACTIVE) continue;
			else break;
		}
		CloseHandle(mytapi.hThread);
	}

	if (mytapi.bGotCommHandle) CloseHandle(mytapi.hComm);

	if (mytapi.bInitialized) lineShutdown(mytapi.hTAPI);

	if (mytapi.bLineDevCapsAlloced) free(mytapi.pLineDevCaps);

	if (mytapi.bLineAddressCapsAlloced) free(mytapi.pLineAddressCaps);

	if (mytapi.bLineTranslateCapsAlloced) free(mytapi.pLineTranslateCaps);

	if (mytapi.bLineDevStatusAlloced) free(mytapi.pLineDevStatus);

	if (mytapi.bLineAddressStatusAlloced) free(mytapi.pLineAddressStatus);

	if (mytapi.bDevConfigAlloced) free(mytapi.pDevConfig);

	if (mytapi.bOldDevConfigAlloced) free(mytapi.pOldDevConfig);

	if (mytapi.bCommPropAlloced) free(mytapi.pCommProp);

	if (mytapi.bCommConfigAlloced) free(mytapi.pCommConfig);

	if (mytapi.bLineCallInfoAlloced) free(mytapi.pLineCallInfo);

	if (mytapi.bLineCallStatusAlloced) free(mytapi.pLineCallStatus);

	if (mytapi.bModemNameAlloced) free(mytapi.szModemName);

	mytapi.bGotCommHandle=FALSE;

	mytapi.bInitialized=FALSE;

	mytapi.bLineDevCapsAlloced=FALSE;

	mytapi.bLineAddressCapsAlloced=FALSE;

	mytapi.bLineTranslateCapsAlloced=FALSE;

	mytapi.bLineDevStatusAlloced=FALSE;

	mytapi.bLineAddressStatusAlloced=FALSE;

	mytapi.bDevConfigAlloced=FALSE;

	mytapi.bOldDevConfigAlloced=FALSE;

	mytapi.bCommPropAlloced=FALSE;

	mytapi.bModemNameAlloced=FALSE;

	mytapi.bCommConfigAlloced=FALSE;

	mytapi.bLineCallInfoAlloced=FALSE;

	mytapi.bLineCallStatusAlloced=FALSE;

	mytapi.bReading=FALSE;

	mytapi.bWaitForCall=FALSE;

	mytapi.bLineOpen=FALSE;

	if (mytapi.hAsyncFuncEnded) {
		CloseHandle(mytapi.hAsyncFuncEnded);
		mytapi.hAsyncFuncEnded=NULL;
	}
}


////////////////////////////////////////////////////////////////////////////////////////
//0016*********************************************************************************
LONG telephonySettings(HWND hwnd)
{
	LONG lrc;
	LPVARSTRING vs=calloc(1,mytapi.pDevConfig->dwTotalSize+15000);
	if (!vs) return LINEERR_NOMEM;

	lrc=mylineGetDevConfig();
	if (lrc) return lrc;

	vs->dwTotalSize=mytapi.pDevConfig->dwTotalSize+15000;
	lrc=lineConfigDialogEdit(mytapi.dwLine,
				hwnd,"comm/datamodem",
				(LPVOID)((LPBYTE)mytapi.pDevConfig
					+mytapi.pDevConfig->dwStringOffset),
				mytapi.pDevConfig->dwStringSize,vs);
	if (lrc) { free(vs); return lrc; }

	lrc=lineSetDevConfig(mytapi.dwLine,
				(LPVOID)((LPBYTE)vs+vs->dwStringOffset),
				vs->dwStringSize,"comm/datamodem");
	if (lrc) { free(vs); return lrc; }

	free(vs);

	lrc=mylineGetDevConfig();
	return lrc;
}

//017****************************************************************************
void CALLBACK LineCallbackProc(DWORD dwDevice,DWORD dwMessage,DWORD dwInstance,
							   DWORD dwParam1,DWORD dwParam2, DWORD dwParam3)
{
	HMENU hMenu;
	DWORD id;
	LONG lrc;

	switch (dwMessage) {
//	case LINE_:
//		break;
	case LINE_ADDRESSSTATE:
		mylineGetAddressStatus();
		hMenu=GetMenu(ghWnd);
		if (mytapi.pLineAddressStatus->dwAddressFeatures
				& LINEADDRFEATURE_MAKECALL)
			EnableMenuItem(hMenu,
				IDM_MAKECALL,MF_ENABLED|MF_BYCOMMAND);
		else
			EnableMenuItem(hMenu,IDM_MAKECALL,
				MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
		switch (dwParam2) {
//		case LINEADDRESSSTATE_
//			break;
		default: break;
		}
		break;
	case LINE_CALLINFO:
		mylineGetCallInfo();
		switch (dwParam1) {
//		case LINECALLINFOSTATE_:
//			break;
		default: break;
		}
		break;
	case LINE_CALLSTATE:
		switch (dwParam3) {
		case LINECALLPRIVILEGE_MONITOR:
			break;
		case LINECALLPRIVILEGE_OWNER:
			mytapi.hCall=(HCALL)dwDevice;
			mylineGetCallStatus();
			mylineGetCallInfo();
			hMenu=GetMenu(ghWnd);
			if (mytapi.pLineCallStatus->dwCallFeatures
					& LINECALLFEATURE_DROP)
				EnableMenuItem(hMenu,
					IDM_DISCONNECT,MF_ENABLED|MF_BYCOMMAND);
			else
				EnableMenuItem(hMenu,IDM_DISCONNECT,
					MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);
			if (mytapi.pLineCallStatus->dwCallFeatures
					& LINECALLFEATURE_ANSWER)
				EnableMenuItem(hMenu,
					IDM_ANSWER,MF_ENABLED|MF_BYCOMMAND);
			else
				EnableMenuItem(hMenu,IDM_ANSWER,
					MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);
			break;			
		default: break;
		}
		switch (dwParam1) {
//		case LINECALLSTATE_:
//			break;
		case LINECALLSTATE_IDLE:
			lineDeallocateCall(mytapi.hCall);
			hMenu=GetMenu(ghWnd);
			if (mytapi.pLineAddressStatus->dwAddressFeatures
					& LINEADDRFEATURE_MAKECALL)
				EnableMenuItem(hMenu,
					IDM_MAKECALL,MF_ENABLED|MF_BYCOMMAND);
			else
				EnableMenuItem(hMenu,IDM_MAKECALL,
					MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);
			break;
		case LINECALLSTATE_OFFERING:
			if (mytapi.bWaitForCall) {
				lrc=lineAnswer(mytapi.hCall,NULL,0);
				if (!(lrc>0)) {
					ProcessTAPIError(lrc);
					myMessageBox("Error answering call");
				}
			}
			break;
		case LINECALLSTATE_DIALTONE:
			switch (dwParam2) {
//			case LINEDIALTONEMODE_:
//				break;
			default: break;
			}
			break;
		case LINECALLSTATE_BUSY:
			switch (dwParam2) {
//			case LINEBUSYMODE_:
//				break;
			default: break;
			}
			break;
		case LINECALLSTATE_SPECIALINFO:
			switch (dwParam2) {
//			case LINESPECIALINFO_:
//				break;
			default: break;
			}
			break;
		case LINECALLSTATE_CONNECTED:
			MessageBeep(0xFFFFFFFF);
			MessageBeep(0xFFFFFFFF);
			MessageBeep(0xFFFFFFFF);
			mytapi.bReading=TRUE;
			if ((mytapi.hThread=CreateThread(NULL,0,
					(LPTHREAD_START_ROUTINE)ReadThread,
					NULL,0,&id))==INVALID_HANDLE_VALUE)
			{
				myMessageBox("Error creating READ Thread");
				break;
			}
			break;
		case LINECALLSTATE_DISCONNECTED:
			if (mytapi.bReading) {
				mytapi.bReading=FALSE;
				while (GetExitCodeThread(mytapi.hThread,&id)) {
					if (id==STILL_ACTIVE) continue;
					else break;
				}
				CloseHandle(mytapi.hThread);
			}
			switch (dwParam2) {
//			case LINEDISCONNECTMODE_:
//				break;
			default: break;
			}
			break;
		case LINECALLSTATE_UNKNOWN:
			break;
		default: break;
		}
		break;
	case LINE_GATHERDIGITS:
		switch (dwParam1) {
//		case LINEGATHERTERM_:
//			break;
		default: break;
		}
		break;
	case LINE_GENERATE:
		switch (dwParam1) {
//		case LINEGENERATETERM_:
//			break;
		default: break;
		}
		break;
	case LINE_LINEDEVSTATE:
		mylineGetLineDevStatus();
		hMenu=GetMenu(ghWnd);
		if (mytapi.pLineDevStatus->dwLineFeatures
				& LINEFEATURE_MAKECALL)
			EnableMenuItem(hMenu,
				IDM_MAKECALL,MF_ENABLED|MF_BYCOMMAND);
		else
			EnableMenuItem(hMenu,IDM_MAKECALL,
				MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);
		switch (dwParam1) {
//		case LINEDEVSTATE_:
//			break;
		default: break;
		}
		break;
	case LINE_MONITORDIGITS:
		switch (dwParam2) {
//		case LINEDIGITMODE_:
//			break;
		default: break;
		}
		break;
	case LINE_MONITORMEDIA:
		switch (dwParam1) {
//		case LINEMEDIAMODE_:
//			break;
		default: break;
		}
		break;
	case LINE_REPLY:
		switch (dwParam2) {

#include "lineerrs.cxx"

		case 0:
			SetEvent(mytapi.hAsyncFuncEnded);
			return;

		default: break;
		}
		break;
	case LINE_REQUEST:
		switch (dwParam1) {
//		case LINEREQUESTMODE_:
//			break;
		default: break;
		}
		break;
	default: break;
	}
	return;
}

void ProcessTAPIError(LONG lrc)
{
	switch (lrc) {

#include "lineerrs.cxx"

	default:
		break;
	}
}

void myMessageBox(LPSTR str)
{
	MessageBox(NULL,str,"Error",MB_OK);
}