How to get caller phone number via TAPI: TAPI, WIndows Mobile

check the website: http://softlancers.in Windows Mobile forum will be started soon in oct 2009 from here.
sample Codes will be uploaded there. you can check from there also.

// TapiCall.h: interface for the CTapiCall class.
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_TAPILINE_H__64E4FCD7_09C8_419D_ABF4_6D864361094B__INCLUDED_)
#define AFX_TAPILINE_H__64E4FCD7_09C8_419D_ABF4_6D864361094B__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
//#define TAPI_CURRENT_VERSION 0x00010004
#define TAPI_CURRENT_VERSION 0x00020000
#include <tapi.h>
 
 
 
 
class CTapiLine  
{
protected:
	HLINEAPP	m_hLineApp; // application's usage handle for TAPI
	HPHONEAPP	m_hPhoneApp; // application's usage handle for TAPI
	HLINE		m_hLine;
	HPHONE		m_hPhone;
	HCALL		m_hCall;
	
	int			m_nDevID;
	int         m_PhoneID;
 
	HANDLE		m_hLineEvent; // line change events
 
	DWORD		m_dwLineMsg;
 
	bool		m_bConnected;
 
	HANDLE	m_hEventFromThread;
	
 
	HANDLE	m_hLineMsgThread;   // TAPI Event monitoring thread.
	bool	m_bStopLineEventThread;
	static DWORD WINAPI LineEventThread(LPVOID lpVoid);
	long	m_lEventThreadResult;
 
	TCHAR* m_szCallerID;
	bool m_bdebug;
	
 
public:
	HWND        m_hWnd; // Window to send messages to
	HANDLE GetHandle(const TCHAR *szClassType, long *lError);
	int PickupIncomingCall();
	void GetErrorString(int nError, TCHAR *&szErrText);
	int MakeOutgoingCall(const TCHAR *szAddress);
	int GetIncomingCall();
	int AnswerCall();
    int HangUp();
	int Close();
	int PreparePhone();
	int Open(int nMode, bool bdebug, HWND hWnd);
	CTapiLine();
	virtual ~CTapiLine();
	enum
	{
	  line_offering,
	  line_callerid,
	  line_connected,
      line_disconnected,
	  line_dialing,
	  line_dialtone,
	  line_proceeding,
	  line_ringback,
	  line_default
	};
 
};
 
#endif // !defined(AFX_TAPILINE_H__64E4FCD7_09C8_419D_ABF4_6D864361094B__INCLUDED_)
 
 
// TapiLine.cpp: implementation of the CTapiLine class.
// Author: T.Yogaramanan
// Include this header if you use any part of the code from this file 
/////////////////////////////////////////////////////////////////////////////
 
#include "stdafx.h"
 
#include "TapiLine.h"
 
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
 
CTapiLine::CTapiLine()
{
	m_hEventFromThread = NULL;
	m_hLineMsgThread = NULL;   // TAPI Event monitoring thread.
	m_bStopLineEventThread = true; 
	m_lEventThreadResult = 0; 
	m_dwLineMsg= 0;
	m_nDevID = 0;
	m_hLineApp = NULL;
	m_hLine = NULL;
	m_hCall = NULL;
	m_bConnected = false;
	m_szCallerID = NULL;
	m_bdebug = false;
 
}
 
CTapiLine::~CTapiLine()
{
	Close();
}
 
// if nMode = 0 then it is data/fax calls
//    nMode = 1 then it is data/fax/voice calls
int CTapiLine::Open(int nMode, bool bdebug ,HWND hWnd)
{
	LINEINITIALIZEEXPARAMS stInitParams;
	LINEDEVCAPS *lpDevCaps =NULL;
	LONG lRet;
	m_szCallerID = new TCHAR[1000]; // must be enough
	m_bdebug = bdebug;
	CString szerror;
	DWORD dwMediaMode;
	DWORD dwNumDevs =0;
	DWORD dwTAPIVer =TAPI_CURRENT_VERSION;;
	DWORD dwTmpVer =0;
	LINEEXTENSIONID stExtID;
 
	if(hWnd!=NULL) m_hWnd = hWnd;
 
	if(!nMode)
		dwMediaMode = LINEMEDIAMODE_DATAMODEM; // data/fax this should be
	else
		dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE ;// for voice this should be it
 
	memset(&stInitParams, 0, sizeof(LINEINITIALIZEEXPARAMS));
	// set the options...
	stInitParams.dwTotalSize = sizeof(LINEINITIALIZEEXPARAMS);
	stInitParams.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT;
	
	// Initialize TAPI.
	lRet = lineInitializeEx(&m_hLineApp, NULL, NULL, L"CallAnswer", &dwNumDevs, &dwTAPIVer, &stInitParams);
	
	if(lRet)  //error
	{
		szerror.Format(L"lineInitializeEx Error:%i",lRet);
		//AfxMessageBox(szerror);
		return lRet;
    }
	else // Number of devices found:
	{
	    szerror.Format(L"lineInitializeEx numDev %i",dwNumDevs);
		//AfxMessageBox(szerror);
	}
	// Got the event handle...
	m_hLineEvent = stInitParams.Handles.hEvent;
 
	m_nDevID = -1;
	// go through the device list and select the appropriate device to transfer voice
	for(int i=0;i<dwNumDevs;i++)
	{
		lRet = lineNegotiateAPIVersion(m_hLineApp, i, dwTAPIVer, dwTAPIVer,	&dwTmpVer, &stExtID);
		if(lRet != 0)
			continue;
				
		lpDevCaps = (LINEDEVCAPS *)malloc(sizeof(LINEDEVCAPS)+1024);// Allocate a little extra memory...
 
		memset(lpDevCaps, 0, sizeof(LINEDEVCAPS)+1024);
		lpDevCaps->dwTotalSize = sizeof(LINEDEVCAPS)+1024;
 
		lRet = lineGetDevCaps(m_hLineApp, i, dwTmpVer, 0, lpDevCaps);
		
		if(lRet)  //error
		{
			free(lpDevCaps);
			lpDevCaps=NULL;
			continue;
		}
		
		char* szText = ((char*)lpDevCaps) + lpDevCaps->dwLineNameOffset;// FOR DEBUGGING
		// for more refer LINEMEDIAMODE_ Constants in MSDN
 
		
 
		if(lpDevCaps->dwMediaModes & dwMediaMode) 
		{
			free(lpDevCaps);
			m_nDevID = i;
			//break;
		}
		free(lpDevCaps);
		
	}
	if(m_nDevID < 0)
		return LINEERR_BADDEVICEID; // no device available
 
	// Open the line...
	lRet = lineOpen(m_hLineApp, m_nDevID, &m_hLine, dwTAPIVer, 0x00000000, 1,LINECALLPRIVILEGE_OWNER,dwMediaMode,NULL);
	if(lRet)
	{
		lineShutdown(m_hLineApp);
		return lRet;
	}
	
	// We want to be notified for everything
	lRet = lineSetStatusMessages(m_hLine, 0x1ffffff, 0);
	if(lRet)
	{	
		lineShutdown(m_hLineApp);
		return lRet;	
	}
	m_bStopLineEventThread = false;
	m_hLineMsgThread = CreateThread(NULL,NULL,LineEventThread,this,NULL,0);
	m_hEventFromThread = CreateEvent(NULL,0,0,NULL);
	return 0;
}
int CTapiLine::PreparePhone()
{
    PHONEINITIALIZEEXPARAMS stInitParams;
	PHONECAPS *lpDevCaps =NULL;
	LONG lRet;
	m_szCallerID = new TCHAR[1000]; // must be enough
	
	CString szerror;
	DWORD dwMediaMode;
	DWORD dwNumDevs =0;
	DWORD dwTAPIVer =TAPI_CURRENT_VERSION;;
	DWORD dwTmpVer =0;
	PHONEEXTENSIONID stExtID;
 
	
 
	memset(&stInitParams, 0, sizeof(PHONEINITIALIZEEXPARAMS));
	// set the options...
	stInitParams.dwTotalSize = sizeof(PHONEINITIALIZEEXPARAMS);
	stInitParams.dwOptions = PHONEINITIALIZEEXOPTION_USEEVENT;
	
	// Initialize TAPI.
	lRet = phoneInitializeEx(&m_hPhoneApp, NULL, NULL, L"CallAnswer", &dwNumDevs, &dwTAPIVer, &stInitParams);
	
	if(lRet)  //error
	{
		szerror.Format(L"lineInitializeEx Error:%i",lRet);
		//AfxMessageBox(szerror);
		return lRet;
    }
	else // Number of devices found:
	{
	    szerror.Format(L"lineInitializeEx numDev %i",dwNumDevs);
		//AfxMessageBox(szerror);
	}
	// Got the event handle...
	//m_hLineEvent = stInitParams.Handles.hEvent;
 
     
	m_nDevID = -1;
	// go through the device list and select the appropriate device to transfer voice
	for(int i=0;i<dwNumDevs;i++)
	{
		lRet = phoneNegotiateAPIVersion(m_hPhoneApp, i, dwTAPIVer, dwTAPIVer,	&dwTmpVer, &stExtID);
		if(lRet != 0)
			continue;
				
		lpDevCaps = (PHONECAPS *)malloc(sizeof(PHONECAPS)+1024);// Allocate a little extra memory...
 
		memset(lpDevCaps, 0, sizeof(PHONECAPS)+1024);
		lpDevCaps->dwTotalSize = sizeof(PHONECAPS)+1024;
 
		lRet = phoneGetDevCaps(m_hPhoneApp, i, dwTmpVer, 0, lpDevCaps);
		
		if(lRet)  //error
		{
			free(lpDevCaps);
			lpDevCaps=NULL;
			continue;
		}
		
		char* szText = ((char*)lpDevCaps) + lpDevCaps->dwPhoneNameOffset;// FOR DEBUGGING
		// for more refer LINEMEDIAMODE_ Constants in MSDN
        m_nDevID = i;  
		
 
	
		
	}
	if(m_nDevID < 0)
		return LINEERR_BADDEVICEID; // no device available
 
	// Open the line...
	lRet = phoneOpen(m_hPhoneApp, m_PhoneID, &m_hPhone, dwTAPIVer, 0x00000000, 1,PHONEPRIVILEGE_OWNER);
	if(lRet)
	{
		szerror.Format(L"Error Line ID %i",dwNumDevs);
		//AfxMessageBox(szerror);
		phoneShutdown(m_hPhoneApp);
		return lRet;
	}
 
	DWORD dwHookswitch = 0;
 
	lRet = phoneGetHookSwitch(m_hPhone,&dwHookswitch );
    if(lRet<0)
	{	
		//AfxMessageBox(L"phoneGetHookSwitch error");
	}
	
	szerror.Format(L"phoneGetHookSwitch:%i",dwHookswitch);
 
	//AfxMessageBox(szerror);
 
	LPDWORD dwVol;
	lRet=phoneGetVolume(m_hPhone,PHONEHOOKSWITCHDEV_HANDSET,dwVol);
 
	lRet = phoneSetVolume(m_hPhone, PHONEHOOKSWITCHDEV_HANDSET, 0x0000FFFF);
	
 
 
	//lRet = phoneSetHookSwitch(m_hPhone,PHONEHOOKSWITCHDEV_HANDSET,PHONEHOOKSWITCHMODE_MICSPEAKER );
 
	
	if(lRet>0)
	{	
		//AfxMessageBox(L"Hookswitch success");
	}
	else
	{
	   switch(lRet)
	   {
	   case PHONEERR_INVALPHONEHANDLE:
		   AfxMessageBox(L"PHONEERR_INVALPHONEHANDLE");
       break;
       case PHONEERR_OPERATIONUNAVAIL:
		   AfxMessageBox(L"PHONEERR_OPERATIONUNAVAIL");
       break;
	   case PHONEERR_NOTOWNER:
		   AfxMessageBox(L"PHONEERR_NOTOWNER");
       break;
	   case PHONEERR_NOMEM:
		   AfxMessageBox(L"PHONEERR_NOMEM");
       break;
	   case PHONEERR_INVALHOOKSWITCHDEV:
		   AfxMessageBox(L"PHONEERR_INVALHOOKSWITCHDEV");
       break;
	   case PHONEERR_INVALHOOKSWITCHMODE:
		   AfxMessageBox(L"PHONEERR_INVALHOOKSWITCHMODE");
       break;
	   case PHONEERR_OPERATIONFAILED:
		   AfxMessageBox(L"PHONEERR_OPERATIONFAILED");
       break;
	   case PHONEERR_INVALPHONESTATE:
		   AfxMessageBox(L"PHONEERR_INVALPHONESTATE");
       break;
	   case PHONEERR_UNINITIALIZED:
		   AfxMessageBox(L"PHONEERR_UNINITIALIZED");
       break;
	   
	   
	   }
		
		
		
		// Wenn ein Fehler aufgetreten ist
	    szerror.Format(L"Error phoneSetHookSwitch %i",lRet);
	    AfxMessageBox(szerror);
        phoneShutdown(m_hPhoneApp);
	}
	// We want to be notified for everything
	//lRet = lineSetStatusMessages(m_hLine, 0x1ffffff, 0);
	/*
	if(lRet)
	{	
		lineShutdown(m_hLineApp);
		return lRet;	
	}
	*/
 
	//m_bStopLineEventThread = false;
	//m_hLineMsgThread = CreateThread(NULL,NULL,LineEventThread,this,NULL,0);
	//m_hEventFromThread = CreateEvent(NULL,0,0,NULL);
	return 0;
 
}
 
int CTapiLine::Close()
{
	LINECALLSTATUS stLineStatus;
	LONG lRet;
	delete m_szCallerID;
 
	if(m_hCall)  // Call might be in progress...
	{
		memset(&stLineStatus, 0, sizeof(LINECALLSTATUS));
 
		lRet = lineGetCallStatus(m_hCall, &stLineStatus); 
			// Technically, lineGetCallStatus returns more info than 
			// there is in the structure.  Since we don't care about it,
			// We just go on our merry way...
		if(!lRet) // If it didn't fail, there's at least a call that needs to be droped.
			lineDrop(m_hCall, NULL, 0);
	}
	m_hCall = NULL;
 
	if(m_hLine)
		lineClose(m_hLine);
	m_hLine = NULL;
 
	if(m_hLineMsgThread)
	{
		m_bStopLineEventThread = true;  // stop the event waiting thread
		WaitForSingleObject(m_hLineMsgThread, INFINITE); // Wait for it to comit suicide..
		CloseHandle(m_hLineMsgThread);
		CloseHandle(m_hEventFromThread);
	}
	if(m_hLineApp)	
		lineShutdown(m_hLineApp);
	m_hLineApp = NULL;
 
	m_hLineMsgThread = NULL;
	m_hEventFromThread = NULL;
	m_hLineMsgThread = NULL;
 
	m_lEventThreadResult = 0; 
	m_dwLineMsg= 0;
	m_nDevID = -1;
	m_bConnected= false;
	return 0;
}
 
 
 
int CTapiLine::GetIncomingCall()
{
	long lRet;
	
	// set the ring b4 receiving the call
	lRet = lineSetNumRings(m_hLine,0,5);
	if(lRet)
		return lRet;
	
	// Now we wait for notification.
	switch(WaitForSingleObject(m_hEventFromThread, INFINITE))
	{
	case WAIT_OBJECT_0:
		if(m_dwLineMsg == LINECALLSTATE_OFFERING)
		{
			
			lRet = lineAnswer(m_hCall, NULL, 0);
			lRet = (lRet>0)?0:lRet;
 
			if(lRet)
				Close();
			return lRet;
		}
		break;
	case WAIT_TIMEOUT:
		return ERROR_TIMEOUT;
	};
	return 0xffffffff; // unknown error
}
 
int CTapiLine::AnswerCall()
{
   PlaySound(NULL,NULL,SND_ASYNC|SND_LOOP|SND_FILENAME);
   int lRet = lineAnswer(m_hCall, NULL, 0);
   return lRet;
}
 
int CTapiLine::PickupIncomingCall()
{
	long lRet;
 
	lRet = linePickup(m_hLine,0,&m_hCall,NULL,NULL);
 
	return (lRet>=0)?0:lRet;
}
 
 
int CTapiLine::MakeOutgoingCall(const TCHAR *szAddress)
{
	long lRet;
 
	LPLINECALLPARAMS lpCallParams;
 
	lpCallParams = (LPLINECALLPARAMS)malloc(sizeof(LINECALLPARAMS)+1024);
	
	memset(lpCallParams,0,sizeof(LINECALLPARAMS)+1024);
 
	lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS)+1024;
 
	    // This is where we configure the line for DATAMODEM usage.
    lpCallParams->dwBearerMode = LINEBEARERMODE_VOICE;
    lpCallParams->dwMediaMode  = LINEMEDIAMODE_INTERACTIVEVOICE;
 
    // This specifies that we want to use only IDLE calls and
    // don't want to cut into a call that might not be IDLE (ie, in use).
    lpCallParams->dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
                                    
    // if there are multiple addresses on line, use first anyway.
    // It will take a more complex application than a simple tty app
    // to use multiple addresses on a line anyway.
    lpCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
    lpCallParams->dwAddressID = 0;
 
    // Address we are dialing.
    lpCallParams->dwDisplayableAddressOffset = sizeof(LINECALLPARAMS);
    lpCallParams->dwDisplayableAddressSize = wcslen(szAddress) *2;
    wcscpy((LPTSTR)lpCallParams+sizeof(LINECALLPARAMS), szAddress);
	
	lRet = lineMakeCall(m_hLine, &m_hCall,szAddress, 0, lpCallParams);
 
	return (lRet>=0)?0:lRet;
}
 
int CTapiLine::HangUp()
{
    LINECALLSTATUS stLineStatus;
	LONG lRet;
	
	
	//if(m_hCall)  // Call might be in progress...
	//{
		memset(&stLineStatus, 0, sizeof(LINECALLSTATUS));
 
		lRet = lineGetCallStatus(m_hCall, &stLineStatus); 
			// Technically, lineGetCallStatus returns more info than 
			// there is in the structure.  Since we don't care about it,
			// We just go on our merry way...
		//if(!lRet) // If it didn't fail, there's at least a call that needs to be droped.
		lineDrop(m_hCall, NULL, 0);
	//}
	m_hCall = NULL;
 
	return lRet;
}
 
//Author: Ramanan.T
HANDLE CTapiLine::GetHandle(const TCHAR *szClassType, long *lError)
{
	if(!m_bConnected)
	{
		*lError = ERROR_DEVICE_NOT_CONNECTED;
		return NULL;
	}
 
	VARSTRING *pvarStrDevID = (VARSTRING *)malloc(sizeof(VARSTRING)+255);
 
	memset(pvarStrDevID,0,sizeof(VARSTRING)+255);
	pvarStrDevID->dwTotalSize = sizeof(VARSTRING)+255;
	
	long lRet = lineGetID(m_hLine,0,m_hCall,LINECALLSELECT_LINE,pvarStrDevID,szClassType);
	if(lRet)
	{
		*lError = lRet;
		return NULL;
	}
 
	*lError = 0;
 
	return *((LPHANDLE)((BYTE *)pvarStrDevID + pvarStrDevID->dwStringOffset));
}
 
//Author: Ramanan.T
DWORD WINAPI CTapiLine::LineEventThread(LPVOID lpVoid)
{
	CTapiLine *pcTapiLine = (CTapiLine *)lpVoid;
	long lRet;
	LINEMESSAGE stLineMsg;
	LINECALLINFO *lpCallInfo;
	bool retval = FALSE;
	//AfxMessageBox(L"LineEventThread");
 
	while(!pcTapiLine->m_bStopLineEventThread)
	{
		// Get a TAPI event if available, wait for 10ms just enough to give up quontum
		switch(WaitForSingleObject(pcTapiLine->m_hLineEvent, 10))
		{
		case WAIT_OBJECT_0:
			//TAPI's got something
			if ((lRet = lineGetMessage(pcTapiLine->m_hLineApp, &stLineMsg, 0)) != 0)
			{
				pcTapiLine->m_lEventThreadResult = lRet;
				return lRet;
			}
			// Process the retruned msg
			switch (stLineMsg.dwMessageID)
			{
			case LINE_REPLY: // Sent after lineMakeCall or lineDrop				
				pcTapiLine->m_lEventThreadResult = (LONG)stLineMsg.dwParam2;
				break;
 
			case LINE_CALLSTATE:  // Sent after change of call state
				switch (stLineMsg.dwParam1)
				{
				    case LINECALLSTATE_DIALTONE: 
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_dialtone,0);
				    break;
 
					case LINECALLSTATE_PROCEEDING:
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_proceeding,0);
                    break;
				 
				    case LINECALLSTATE_DIALING:
					 SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_dialing,0);
					break;
								
				    case LINECALLSTATE_OFFERING:	//Incoming call is offering.
						//  Get the call handle
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_offering,0);
						 retval = PlaySound(L"\\Windows\\Alarm1.wav",NULL,SND_ASYNC|SND_LOOP|SND_FILENAME);
						pcTapiLine->m_hCall = (HCALL)stLineMsg.hDevice;
 
						pcTapiLine->m_dwLineMsg = LINECALLSTATE_OFFERING;
						SetEvent(pcTapiLine->m_hEventFromThread);
						break;
 
					case LINECALLSTATE_IDLE:
						//PlaySound(NULL,NULL,SND_ASYNC|SND_LOOP|SND_FILENAME);
						lineDrop(pcTapiLine->m_hCall, NULL, 0);
						pcTapiLine->m_hCall = NULL;
						break;
 
					case LINECALLSTATE_RINGBACK: 
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_ringback,0);
                    break;
 
 
					case LINECALLSTATE_CONNECTED:
						
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_connected,0);
						if(stLineMsg.dwCallbackInstance == 1)
						{
							pcTapiLine->m_dwLineMsg = LINECALLSTATE_CONNECTED;
							SetEvent(pcTapiLine->m_hEventFromThread);
							pcTapiLine->m_bConnected = true;
						}
 
						break;
 
					case LINECALLSTATE_DISCONNECTED:
						
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_disconnected,stLineMsg.dwParam2);
						switch (stLineMsg.dwParam2) 
						{// currently these r not handled separately
							case LINEDISCONNECTMODE_NORMAL:
							case LINEDISCONNECTMODE_UNKNOWN:
							case LINEDISCONNECTMODE_REJECT:
							case LINEDISCONNECTMODE_PICKUP:
							case LINEDISCONNECTMODE_FORWARDED:
							case LINEDISCONNECTMODE_BUSY:
							case LINEDISCONNECTMODE_NOANSWER:
							case LINEDISCONNECTMODE_BADADDRESS:
							case LINEDISCONNECTMODE_UNREACHABLE:
							case LINEDISCONNECTMODE_CONGESTION:
							case LINEDISCONNECTMODE_INCOMPATIBLE:
							case LINEDISCONNECTMODE_UNAVAIL:
							case LINEDISCONNECTMODE_NODIALTONE:
							default:
								// Got disconnected, so drop the call
								lineDrop((HCALL)stLineMsg.hDevice, NULL, 0);
								PlaySound(NULL,NULL,SND_ASYNC|SND_LOOP|SND_FILENAME);
								pcTapiLine->m_bConnected = false;
								break;
						}					
						break;
 
					default:
						SendMessage(pcTapiLine->m_hWnd,WM_PHONE,line_default,stLineMsg.dwParam2);
						break;
				}
				break;
 
			case LINE_CALLINFO: //  Call Info is available
				
				if(stLineMsg.dwParam1 == LINECALLINFOSTATE_CALLERID)
				{  //Caller ID became available.
					lpCallInfo = (LINECALLINFO *)malloc(sizeof(LINECALLINFO)+1000);
					memset(lpCallInfo, 0, sizeof(LINECALLINFO)+1024);
					lpCallInfo->dwTotalSize = sizeof(LINECALLINFO)+1024;
					lineGetCallInfo(pcTapiLine->m_hCall, lpCallInfo);
					if (lpCallInfo->dwTotalSize < lpCallInfo->dwNeededSize)
					{
						lpCallInfo = (LINECALLINFO *)realloc(lpCallInfo, lpCallInfo->dwNeededSize);
						lineGetCallInfo(pcTapiLine->m_hCall, lpCallInfo);
 
						    
					}
					memset(pcTapiLine->m_szCallerID,0,2000);
					wsprintf(pcTapiLine->m_szCallerID,_T("%s"),(LPCTSTR)((LPBYTE)lpCallInfo + lpCallInfo->dwCallerIDOffset));
                    SendMessage(pcTapiLine->m_hWnd,WM_PHONE, line_callerid,(WPARAM)pcTapiLine->m_szCallerID);
				} 
 
				break;
 
			default:
				break;
			};
			break;
 
		case WAIT_TIMEOUT:
			//PlaySound(NULL,NULL,SND_ASYNC|SND_LOOP|SND_FILENAME);
			break;;
			
		default:
			continue;
		};
	}
	return 0;
}
 
//Author: Ramanan.T
void CTapiLine::GetErrorString(int nError, TCHAR *&szErrText)
{
	szErrText = (TCHAR*)malloc(255);
	switch(nError)
	{
	case LINEERR_ALLOCATED:
		wcscpy(szErrText,L"LINEERR_ALLOCATED");
		break;
	case LINEERR_BADDEVICEID:
		wcscpy(szErrText,L"LINEERR_BADDEVICEID");
		break;
	case LINEERR_BEARERMODEUNAVAIL:
		wcscpy(szErrText,L"LINEERR_BEARERMODEUNAVAIL");
		break;
	case LINEERR_CALLUNAVAIL:
		wcscpy(szErrText,L"LINEERR_CALLUNAVAIL");
		break;
	case LINEERR_COMPLETIONOVERRUN:
		wcscpy(szErrText,L"LINEERR_COMPLETIONOVERRUN");
		break;
	case LINEERR_CONFERENCEFULL:
		wcscpy(szErrText,L"LINEERR_CONFERENCEFULL");
		break;
	case LINEERR_DIALBILLING:
		wcscpy(szErrText,L"LINEERR_DIALBILLING");
		break;
	case LINEERR_DIALDIALTONE:
		wcscpy(szErrText,L"LINEERR_DIALDIALTONE");
		break;
	case LINEERR_DIALPROMPT:
		wcscpy(szErrText,L"LINEERR_DIALPROMPT");
		break;
	case LINEERR_DIALQUIET:
		wcscpy(szErrText,L"LINEERR_DIALQUIET");
		break;
	case LINEERR_INCOMPATIBLEAPIVERSION:
		wcscpy(szErrText,L"LINEERR_INCOMPATIBLEAPIVERSION");
		break;
	case LINEERR_INCOMPATIBLEEXTVERSION:
		wcscpy(szErrText,L"LINEERR_INCOMPATIBLEEXTVERSION");
		break;          
	case LINEERR_INIFILECORRUPT:
		wcscpy(szErrText,L"LINEERR_INIFILECORRUPT");
		break;                  
	case LINEERR_INUSE:
		wcscpy(szErrText,L"LINEERR_INUSE");
		break;                           
	case LINEERR_INVALADDRESS:
		wcscpy(szErrText,L"LINEERR_INVALADDRESS");
		break;                    
	case LINEERR_INVALADDRESSID:
		wcscpy(szErrText,L"LINEERR_INVALADDRESSID");
		break;                  
	case LINEERR_INVALADDRESSMODE:
		wcscpy(szErrText,L"LINEERR_INVALADDRESSMODE");
		break;                
	case LINEERR_INVALADDRESSSTATE:
		wcscpy(szErrText,L"LINEERR_INVALADDRESSSTATE");
		break;               
	case LINEERR_INVALAPPHANDLE:
		wcscpy(szErrText,L"LINEERR_INVALAPPHANDLE");
		break;                  
	case LINEERR_INVALAPPNAME:
		wcscpy(szErrText,L"LINEERR_INVALAPPNAME");
		break;                    
	case LINEERR_INVALBEARERMODE:
		wcscpy(szErrText,L"LINEERR_INVALBEARERMODE");
		break;                 
	case LINEERR_INVALCALLCOMPLMODE:
		wcscpy(szErrText,L"LINEERR_INVALCALLCOMPLMODE");
		break;              
	case LINEERR_INVALCALLHANDLE:
		wcscpy(szErrText,L"LINEERR_INVALCALLHANDLE");
		break;                 
	case LINEERR_INVALCALLPARAMS:
		wcscpy(szErrText,L"LINEERR_INVALCALLPARAMS");
		break;                 
	case LINEERR_INVALCALLPRIVILEGE:
		wcscpy(szErrText,L"LINEERR_INVALCALLPRIVILEGE");
		break;              
	case LINEERR_INVALCALLSELECT:
		wcscpy(szErrText,L"LINEERR_INVALCALLSELECT");
		break;                 
	case LINEERR_INVALCALLSTATE:
		wcscpy(szErrText,L"LINEERR_INVALCALLSTATE");
		break;                  
	case LINEERR_INVALCALLSTATELIST:
		wcscpy(szErrText,L"LINEERR_INVALCALLSTATELIST");
		break;              
	case LINEERR_INVALCARD:
		wcscpy(szErrText,L"LINEERR_INVALCARD");
		break;                       
	case LINEERR_INVALCOMPLETIONID:
		wcscpy(szErrText,L"LINEERR_INVALCOMPLETIONID");
		break;               
	case LINEERR_INVALCONFCALLHANDLE:
		wcscpy(szErrText,L"LINEERR_INVALCONFCALLHANDLE");
		break;             
	case LINEERR_INVALCONSULTCALLHANDLE:
		wcscpy(szErrText,L"LINEERR_INVALCONSULTCALLHANDLE");
		break;          
	case LINEERR_INVALCOUNTRYCODE:
		wcscpy(szErrText,L"LINEERR_INVALCOUNTRYCODE");
		break;                
	case LINEERR_INVALDEVICECLASS:
		wcscpy(szErrText,L"LINEERR_INVALDEVICECLASS");
		break;                
	case LINEERR_INVALDEVICEHANDLE:
		wcscpy(szErrText,L"LINEERR_INVALDEVICEHANDLE");
		break;               
	case LINEERR_INVALDIALPARAMS:
		wcscpy(szErrText,L"LINEERR_INVALDIALPARAMS");
		break;                 
	case LINEERR_INVALDIGITLIST:
		wcscpy(szErrText,L"LINEERR_INVALDIGITLIST");
		break;                  
	case LINEERR_INVALDIGITMODE:
		wcscpy(szErrText,L"LINEERR_INVALDIGITMODE");
		break;                  
	case LINEERR_INVALDIGITS:
		wcscpy(szErrText,L"LINEERR_INVALDIGITS");
		break;                    
	case LINEERR_INVALEXTVERSION:
		wcscpy(szErrText,L"LINEERR_INVALEXTVERSION");
		break;                 
	case LINEERR_INVALGROUPID:
		wcscpy(szErrText,L"LINEERR_INVALGROUPID");
		break;                    
	case LINEERR_INVALLINEHANDLE:
		wcscpy(szErrText,L"LINEERR_INVALLINEHANDLE");
		break;                
	case LINEERR_INVALLINESTATE:
		wcscpy(szErrText,L"LINEERR_INVALLINESTATE");
		break;                  
	case LINEERR_INVALLOCATION:
		wcscpy(szErrText,L"LINEERR_INVALLOCATION");
		break;                   
	case LINEERR_INVALMEDIALIST:
		wcscpy(szErrText,L"LINEERR_INVALMEDIALIST");
		break;                  
	case LINEERR_INVALMEDIAMODE:
		wcscpy(szErrText,L"LINEERR_INVALMEDIAMODE");
		break;                  
	case LINEERR_INVALMESSAGEID:
		wcscpy(szErrText,L"LINEERR_INVALMESSAGEID");
		break;                  
	case LINEERR_INVALPARAM:
		wcscpy(szErrText,L"LINEERR_INVALPARAM");
		break;                      
	case LINEERR_INVALPARKID:
		wcscpy(szErrText,L"LINEERR_INVALPARKID");
		break;                     
	case LINEERR_INVALPARKMODE:
		wcscpy(szErrText,L"LINEERR_INVALPARKMODE");
		break;                   
	case LINEERR_INVALPOINTER:
		wcscpy(szErrText,L"LINEERR_INVALPOINTER");
		break;                    
	case LINEERR_INVALPRIVSELECT:
		wcscpy(szErrText,L"LINEERR_INVALPRIVSELECT");
		break;                 
	case LINEERR_INVALRATE:
		wcscpy(szErrText,L"LINEERR_INVALRATE");
		break;                       
	case LINEERR_INVALREQUESTMODE:
		wcscpy(szErrText,L"LINEERR_INVALREQUESTMODE");
		break;                
	case LINEERR_INVALTERMINALID:
		wcscpy(szErrText,L"LINEERR_INVALTERMINALID");
		break;                 
	case LINEERR_INVALTERMINALMODE:
		wcscpy(szErrText,L"LINEERR_INVALTERMINALMODE");
		break;               
	case LINEERR_INVALTIMEOUT:
		wcscpy(szErrText,L"LINEERR_INVALTIMEOUT");
		break;                    
	case LINEERR_INVALTONE:
		wcscpy(szErrText,L"LINEERR_INVALTONE");
		break;                       
	case LINEERR_INVALTONELIST:
		wcscpy(szErrText,L"LINEERR_INVALTONELIST");
		break;                   
	case LINEERR_INVALTONEMODE:
		wcscpy(szErrText,L"LINEERR_INVALTONEMODE");
		break;                   
	case LINEERR_INVALTRANSFERMODE:
		wcscpy(szErrText,L"LINEERR_INVALTRANSFERMODE");
		break;               
	case LINEERR_LINEMAPPERFAILED:
		wcscpy(szErrText,L"LINEERR_LINEMAPPERFAILED");
		break;                
	case LINEERR_NOCONFERENCE:
		wcscpy(szErrText,L"LINEERR_NOCONFERENCE");
		break;                    
	case LINEERR_NODEVICE:
		wcscpy(szErrText,L"LINEERR_NODEVICE");
		break;                        
	case LINEERR_NODRIVER:
		wcscpy(szErrText,L"LINEERR_NODRIVER");
		break;                        
	case LINEERR_NOMEM:
		wcscpy(szErrText,L"LINEERR_NOMEM");
		break;                           
	case LINEERR_NOREQUEST:
		wcscpy(szErrText,L"LINEERR_NOREQUEST");
		break;                       
	case LINEERR_NOTOWNER:
		wcscpy(szErrText,L"LINEERR_NOTOWNER");
		break;                        
	case LINEERR_NOTREGISTERED:
		wcscpy(szErrText,L"LINEERR_NOTREGISTERED");
		break;                   
	case LINEERR_OPERATIONFAILED:
		wcscpy(szErrText,L"LINEERR_OPERATIONFAILED");
		break;                 
	case LINEERR_OPERATIONUNAVAIL:
		wcscpy(szErrText,L"LINEERR_OPERATIONUNAVAIL");
		break;                
	case LINEERR_RATEUNAVAIL:
		wcscpy(szErrText,L"LINEERR_RATEUNAVAIL");
		break;                     
	case LINEERR_RESOURCEUNAVAIL:
		wcscpy(szErrText,L"LINEERR_RESOURCEUNAVAIL");
		break;                 
	case LINEERR_REQUESTOVERRUN:
		wcscpy(szErrText,L"LINEERR_REQUESTOVERRUN");
		break;                  
	case LINEERR_STRUCTURETOOSMALL:
		wcscpy(szErrText,L"LINEERR_STRUCTURETOOSMALL");
		break;               
	case LINEERR_TARGETNOTFOUND:
		wcscpy(szErrText,L"LINEERR_TARGETNOTFOUND");
		break;                  
	case LINEERR_TARGETSELF:
		wcscpy(szErrText,L"LINEERR_TARGETSELF");
		break;                      
	case LINEERR_UNINITIALIZED:
		wcscpy(szErrText,L"LINEERR_UNINITIALIZED");
		break;                   
	case LINEERR_USERUSERINFOTOOBIG:
		wcscpy(szErrText,L"LINEERR_USERUSERINFOTOOBIG");
		break;           
	case LINEERR_REINIT:
		wcscpy(szErrText,L"LINEERR_REINIT");
		break;
	case LINEERR_ADDRESSBLOCKED:
		wcscpy(szErrText,L"LINEERR_ADDRESSBLOCKED");
		break;
	case LINEERR_BILLINGREJECTED:
		wcscpy(szErrText,L"LINEERR_BILLINGREJECTED");
		break;
	case LINEERR_INVALFEATURE:
		wcscpy(szErrText,L"LINEERR_INVALFEATURE");
		break;
	case LINEERR_NOMULTIPLEINSTANCE:
		wcscpy(szErrText,L"LINEERR_NOMULTIPLEINSTANCE");
		break;
	case LINEERR_INVALAGENTID:
		wcscpy(szErrText,L"LINEERR_INVALAGENTID");
		break;
	case LINEERR_INVALAGENTGROUP:
		wcscpy(szErrText,L"LINEERR_INVALAGENTGROUP");
		break;
	case LINEERR_INVALPASSWORD:
		wcscpy(szErrText,L"LINEERR_INVALPASSWORD");
		break;
	case LINEERR_INVALAGENTSTATE:
		wcscpy(szErrText,L"LINEERR_INVALAGENTSTATE");
		break;
	case LINEERR_INVALAGENTACTIVITY:
		wcscpy(szErrText,L"LINEERR_INVALAGENTACTIVITY");
		break;
	case LINEERR_DIALVOICEDETECT:
		wcscpy(szErrText,L"LINEERR_DIALVOICEDETECT");
		break;
	default:
		free(szErrText);
		FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,nError,0,(LPTSTR)&szErrText,0,NULL);
	};
}
 
 
// TAPIPhonelDlg.h : header file
//
// Author: Srikanth Kanchari
// Include this header if you use any part of the code from this file 
/////////////////////////////////////////////////////////////////////////////
 
 
#pragma once
#include "afxwin.h"
 
// CTAPIPhonelDlg dialog
class CTAPIPhonelDlg : public CDialog
{
// Construction
public:
	CTAPIPhonelDlg(CWnd* pParent = NULL);	// standard constructor
 
	CTapiLine m_line;
// Dialog Data
	enum { IDD = IDD_TAPIPHONEL_DIALOG };
 
 
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
 
// Implementation
protected:
	HICON m_hIcon;
 
	// Generated message map functions
	virtual BOOL OnInitDialog();
#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
	afx_msg void OnSize(UINT /*nType*/, int /*cx*/, int /*cy*/);
		afx_msg HRESULT OnPhone(WPARAM wParam, LPARAM lParam);
#endif
	DECLARE_MESSAGE_MAP()
public:
	afx_msg void OnBnClickedButton1();
	CListBox m_lBox;
	afx_msg void OnBnClickedButton2();
	afx_msg void OnBnClickedButton3();
};
// TAPIPhonelDlg.cpp : implementation file
//
// Author: Srikanth Kanchari
// Include this header if you use any part of the code from this file 
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "TAPIPhonel.h"
#include "TAPIPhonelDlg.h"
 
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
 
// CTAPIPhonelDlg dialog
 
CTAPIPhonelDlg::CTAPIPhonelDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CTAPIPhonelDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
 
void CTAPIPhonelDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST1, m_lBox);
}
 
BEGIN_MESSAGE_MAP(CTAPIPhonelDlg, CDialog)
#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
	ON_WM_SIZE()
#endif
	//}}AFX_MSG_MAP
	ON_BN_CLICKED(IDC_BUTTON1, &CTAPIPhonelDlg::OnBnClickedButton1)
	ON_MESSAGE(WM_PHONE,CTAPIPhonelDlg::OnPhone)
	ON_BN_CLICKED(IDC_BUTTON2, &CTAPIPhonelDlg::OnBnClickedButton2)
	ON_BN_CLICKED(IDC_BUTTON3, &CTAPIPhonelDlg::OnBnClickedButton3)
 
END_MESSAGE_MAP()
 
 
// CTAPIPhonelDlg message handlers
 
BOOL CTAPIPhonelDlg::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
 
 
	  m_line.PreparePhone(); 
	m_line.Open(1,true, this->GetSafeHwnd());
	// TODO: Add extra initialization here
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}
void CTAPIPhonelDlg::OnBnClickedButton1()
{
	m_lBox.AddString(L"drop");
    int icount = m_lBox.GetCount();
    m_lBox.SetTopIndex(icount-1);
	
	
	m_line.HangUp();
	// TODO: Add your control notification handler code here
}
HRESULT CTAPIPhonelDlg::OnPhone(WPARAM wParam, LPARAM lParam)
{
   int icount;
   CString szins;
	switch(wParam)
   {
   case CTapiLine::line_offering:
	    szins = L"offerring";
   break;
   case CTapiLine::line_callerid:
	    szins = (TCHAR*)lParam;
  
   break;
   case CTapiLine::line_connected:
	    szins = L"connected";
   break;
   case CTapiLine::line_disconnected:
	   szins = L"disconnected";
   break;
 
   case CTapiLine::line_dialing:
	   szins = L"line dialing";
   break;
   case CTapiLine::line_dialtone:
       szins = L"line tone";
	   break;
   case CTapiLine::line_proceeding:
	   szins = L"line proceeding";
	   break;
   case CTapiLine::line_ringback:
	   szins = L"line ringback";
   break;
   case CTapiLine::line_default:
	   szins = L"line default";
	   break;
   default:
	   szins = L"nix passiert";
   break;
 
   }
 
   m_lBox.AddString(szins);
    icount = m_lBox.GetCount();
    m_lBox.SetTopIndex(icount-1);
	
   
   UpdateData(FALSE);
 
 
 return true;
}
void CTAPIPhonelDlg::OnBnClickedButton2()
{
	m_lBox.AddString(L"answer");
    int icount = m_lBox.GetCount();
    m_lBox.SetTopIndex(icount-1);
	
	
	m_line.AnswerCall();
	
	// TODO: Add your control notification handler code here
}
 
void CTAPIPhonelDlg::OnBnClickedButton3()
{
	m_line.MakeOutgoingCall(L"9811270686");
	// TODO: Add your control notification handler code here
}
#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
void CTAPIPhonelDlg::OnSize(UINT /*nType*/, int /*cx*/, int /*cy*/)
{
	if (AfxIsDRAEnabled())
	{
		DRA::RelayoutDialog(
			AfxGetResourceHandle(), 
			this->m_hWnd, 
			DRA::GetDisplayMode() != DRA::Portrait ? 
			MAKEINTRESOURCE(IDD_TAPIPHONEL_DIALOG_WIDE) : 
			MAKEINTRESOURCE(IDD_TAPIPHONEL_DIALOG));
	}
}
#endif

Select all Open in new window

Question

How to get caller phone number via TAPI

Subscribe now for full access to Experts Exchange and get

Instant Access to this Solution

TAPI

WIndows Mobile

Windows MobileProgramming

Handheld and PDA Programming

Trusted by hundreds of thousands everyday for fast, accurate and reliable tech support.

See what Experts Exchange can do for you.

Got a question?

We've got the answer.

Need individual assistance?

Our experts are ready to help.

Want to learn from the best?

Read articles from industry experts.

Working on a long term project?

Store your work and research.

What Makes Experts Exchange Unique?

Trusted by the world's most respected brands.

Faithfully serving IT professionals since 1996.

Related Solutions

Free Tech Articles

Cloud Class Webinars

Join the Community

Give a Little. Get a Lot.

Answers

3 Ways to Join

The Experts

The Experts

Testimonials

Testimonials

Testimonials

Business Clients

Business Clients

In the Press

In the Press

In the Press