exttapisampledlg.cpp

Retrieving IMEI, IMSI and Operator Status using Extended TAPI functions Windows Mobile

// ExtTAPISampleDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ExtTAPISample.h"
#include "ExtTAPISampleDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

void FAR PASCAL CExtTAPISampleDlg::lineCallback(DWORD hDevice,
												DWORD dwMsg,
												DWORD dwCallbackInstance,
												DWORD dwParam1,
												DWORD dwParam2,
												DWORD dwParam3)
{
}

// CExtTAPISampleDlg dialog

CExtTAPISampleDlg::CExtTAPISampleDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CExtTAPISampleDlg::IDD, pParent)
{
	m_hIcon				= AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	m_hLineApp			= NULL;
	m_dwDevices			= 0;
	m_dwLowAPIVersion	= 0;
	m_dwCellularId		= 0;
}

void CExtTAPISampleDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST_INFO, m_wndInfo);
}

BEGIN_MESSAGE_MAP(CExtTAPISampleDlg, CDialog)
	ON_WM_SIZE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


// CExtTAPISampleDlg message handlers

BOOL CExtTAPISampleDlg::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

	if(0 == InitializeTAPI())
	{
		m_dwCellularId	= GetCellularLineId();
	}

	DisplayCellularInfo(&m_wndInfo);
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CExtTAPISampleDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType,cx,cy);

	if(m_wndInfo.GetSafeHwnd())
	{
		m_wndInfo.SetWindowPos(NULL,DRA::SCALEX(X_OFFSET),DRA::SCALEY(Y_OFFSET),
							   DRA::SCALEX(cx - X_OFFSET * 2),DRA::SCALEY(cy - Y_OFFSET * 2),
							   SWP_NOZORDER);

		CRect	rc;

		m_wndInfo.GetClientRect(&rc);
		m_wndInfo.SetColumnWidth(0,rc.Width()/2);
		m_wndInfo.SetColumnWidth(1,rc.Width()/2);
	}
}

void CExtTAPISampleDlg::OnDestroy()
{
	ShutdownTAPI();

	CDialog::OnDestroy();
}

long CExtTAPISampleDlg::InitializeTAPI()
{
	LINEINITIALIZEEXPARAMS	sLineParam;

	memset(&sLineParam,0,sizeof(LINEINITIALIZEEXPARAMS));

	sLineParam.dwTotalSize	= sizeof(LINEINITIALIZEEXPARAMS);
	sLineParam.dwOptions	= LINEINITIALIZEEXOPTION_USEHIDDENWINDOW; 

	m_dwLowAPIVersion		= TAPI_CURRENT_VERSION;

	long	lReturn	= lineInitializeEx(&m_hLineApp,
									   theApp.m_hInstance,
									   lineCallback,
									   TAPI_FRIENDLY_NAME,
									   &m_dwDevices,
									   &m_dwLowAPIVersion,
									   &sLineParam);

	return lReturn;
}

void CExtTAPISampleDlg::ShutdownTAPI()
{
	if(m_hLineApp)
	{
		lineShutdown(m_hLineApp);
	}
}

DWORD CExtTAPISampleDlg::GetCellularLineId()
{
	DWORD				dwReturn		= 0;
	long				lResult			= 0;
	LINEEXTENSIONID		sLineExt		= {0};
	LPLINEDEVCAPS		lpLineDevCaps	= NULL;	
	DWORD				dwAPIVersion	= TAPI_CURRENT_VERSION;
	BOOL				bContinue		= TRUE;

	for(DWORD dwLine=0; dwLine<m_dwDevices && bContinue; ++dwLine)
	{
		lResult		= lineNegotiateAPIVersion(m_hLineApp,dwLine,m_dwLowAPIVersion,TAPI_CURRENT_VERSION,&dwAPIVersion,&sLineExt);

		if(0 == lResult)
		{
			lpLineDevCaps	= (LPLINEDEVCAPS)LocalAlloc(LPTR,sizeof(LINEDEVCAPS));
			lResult			= LINEERR_STRUCTURETOOSMALL;

			lpLineDevCaps->dwTotalSize	= sizeof(LINEDEVCAPS);
			lpLineDevCaps->dwNeededSize	= sizeof(LINEDEVCAPS);

			while(LINEERR_STRUCTURETOOSMALL == lResult)
			{
				lResult	= lineGetDevCaps(m_hLineApp,dwLine,TAPI_CURRENT_VERSION,0,lpLineDevCaps);

				if(LINEERR_STRUCTURETOOSMALL == lResult || lpLineDevCaps->dwTotalSize < lpLineDevCaps->dwNeededSize)
				{
					lpLineDevCaps	= (LPLINEDEVCAPS)LocalReAlloc(lpLineDevCaps,lpLineDevCaps->dwNeededSize,LMEM_MOVEABLE);
					lResult			= LINEERR_STRUCTURETOOSMALL;

					lpLineDevCaps->dwTotalSize	= lpLineDevCaps->dwNeededSize;
				}
			}

			if(0 == lResult)
			{
				TCHAR szName[512];

				memcpy((PVOID)szName,(PVOID)((BYTE*)lpLineDevCaps + lpLineDevCaps ->dwLineNameOffset), 
					    lpLineDevCaps->dwLineNameSize);

				szName[lpLineDevCaps->dwLineNameSize]	= 0;

				if(_tcscmp(szName,CELLTSP_LINENAME_STRING) == 0)
				{
					dwReturn	= dwLine;
					bContinue	= FALSE;
				}
			}

			LocalFree((HLOCAL)lpLineDevCaps);
		}
	}

	return dwReturn;
}

void  CExtTAPISampleDlg::DisplayCellularInfo(CListCtrl* pList)
{
	pList->DeleteAllItems();
	pList->ModifyStyle(0,LVS_REPORT);
	pList->SetExtendedStyle(LVS_EX_FULLROWSELECT);

	pList->InsertColumn(0,L"",LVCFMT_LEFT,80);
	pList->InsertColumn(1,L"",LVCFMT_LEFT,120);

	DWORD	dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
	HLINE	hLine		= NULL;
	long	lReturn		= lineOpen(m_hLineApp,m_dwCellularId,&hLine,
								   TAPI_CURRENT_VERSION,0,(DWORD)this,
								   LINECALLPRIVILEGE_OWNER,dwMediaMode,0);

	if(0 != lReturn || !hLine)
	{
		CString	strError;

		strError.Format(TEXT("Error Opening the Cellular Line with: %X"),lReturn);

		MessageBox(strError,TEXT("TAPI Info"),MB_OK | MB_ICONEXCLAMATION);

		return;
	}

	LINEGENERALINFO* pInfo = (LINEGENERALINFO*)LocalAlloc(LPTR,sizeof(LINEGENERALINFO));

	pInfo->dwTotalSize	= sizeof(LINEGENERALINFO);
	lReturn				= LINEERR_STRUCTURETOOSMALL;

	while(LINEERR_STRUCTURETOOSMALL == lReturn)
	{
		lReturn	= lineGetGeneralInfo(hLine,pInfo);

		if(LINEERR_STRUCTURETOOSMALL == lReturn || pInfo->dwTotalSize < pInfo->dwNeededSize)
		{
			pInfo	= (LINEGENERALINFO*)LocalReAlloc(pInfo,pInfo->dwNeededSize,LMEM_MOVEABLE);
			lReturn	= LINEERR_STRUCTURETOOSMALL;

			pInfo->dwTotalSize	= pInfo->dwNeededSize;
		}
	}

	if(0 == lReturn)
	{
		TCHAR	szInfo[MAX_PATH];
		int		nItem;

		if(pInfo->dwSerialNumberSize > 0)
		{
			GetLineGeneralInfo(pInfo,szInfo,pInfo->dwSerialNumberSize,pInfo->dwSerialNumberOffset);

			nItem	= pList->InsertItem(0,TEXT("IMEI"),0);

			pList->SetItemText(nItem,1,szInfo);
		}

		if(pInfo->dwSubscriberNumberSize > 0)
		{
			GetLineGeneralInfo(pInfo,szInfo,pInfo->dwSubscriberNumberSize,pInfo->dwSubscriberNumberOffset);

			nItem	= pList->InsertItem(1,TEXT("IMSI"),0);
			
			pList->SetItemText(nItem,1,szInfo);
		}

		if(pInfo->dwManufacturerSize > 0)
		{
			GetLineGeneralInfo(pInfo,szInfo,pInfo->dwManufacturerSize,pInfo->dwManufacturerOffset);

			nItem	= pList->InsertItem(2,TEXT("Manufacturer"),0);
			
			pList->SetItemText(nItem,1,szInfo);
		}

		if(pInfo->dwModelSize > 0)
		{
			GetLineGeneralInfo(pInfo,szInfo,pInfo->dwModelSize,pInfo->dwModelOffset);

			nItem	= pList->InsertItem(3,TEXT("Modal"),0);
			
			pList->SetItemText(nItem,1,szInfo);
		}

		if(pInfo->dwRevisionSize > 0)
		{
			GetLineGeneralInfo(pInfo,szInfo,pInfo->dwRevisionSize,pInfo->dwRevisionOffset);

			nItem	= pList->InsertItem(4,TEXT("Revision"),0);
			
			pList->SetItemText(nItem,1,szInfo);
		}
	}

	LocalFree((HLOCAL)pInfo);

	if(0 != lReturn || !hLine)
	{
		CString	strError;

		strError.Format(TEXT("Error getting the Operator Status with: %X"),lReturn);

		MessageBox(strError,TEXT("TAPI Info"),MB_OK | MB_ICONEXCLAMATION);

		return;
	}

	LINEOPERATORSTATUS* pStatus	= (LINEOPERATORSTATUS*)LocalAlloc(LPTR,sizeof(LINEOPERATORSTATUS));

	pStatus->dwTotalSize		= sizeof(LINEOPERATORSTATUS);
	lReturn						= LINEERR_STRUCTURETOOSMALL;

	while(LINEERR_STRUCTURETOOSMALL == lReturn)
	{
		lReturn	= lineGetOperatorStatus(hLine,pStatus);

		if(LINEERR_STRUCTURETOOSMALL == lReturn || pStatus->dwTotalSize < pStatus->dwNeededSize)
		{
			pStatus	= (LINEOPERATORSTATUS*)LocalReAlloc(pStatus,pStatus->dwNeededSize,LMEM_MOVEABLE);
			lReturn	= LINEERR_STRUCTURETOOSMALL;

			pStatus->dwTotalSize	= pStatus->dwNeededSize;
		}
	}

	if(0 == lReturn)
	{
		TCHAR	szInfo[MAX_PATH];
		int		nItem;
		CString	strEntry;

		nItem	= pList->InsertItem(5,TEXT("No. of Operators"),0);

		wsprintf(szInfo,TEXT("%d"),pStatus->dwAvailableCount);
			
		pList->SetItemText(nItem,1,szInfo);

		LPLINEOPERATOR	pOperator	= (LPLINEOPERATOR)(pStatus + pStatus->dwAvailableOffset);

		for(DWORD dwOperator=0; dwOperator<pStatus->dwAvailableCount; ++dwOperator)
		{
			if(pOperator[dwOperator].dwValidFields & LINEOPFORMAT_ALPHALONG)
			{
				strEntry.Format(TEXT("Operator #%d"),dwOperator + 1);

				nItem	= pList->InsertItem(dwOperator + 5 + 1,strEntry,0);

				if(pOperator[dwOperator].dwValidFields & LINEOPFORMAT_NUMERIC)
					wsprintf(szInfo,TEXT("%s (%s)"),pOperator[dwOperator].lpszLongName,pOperator[dwOperator].lpszNumName);
				else
					wsprintf(szInfo,TEXT("%s"),pOperator[dwOperator].lpszLongName);
					
				pList->SetItemText(nItem,1,szInfo);
			}
		}
	}

	LINEOPERATOR	sOperator;

	lReturn	= lineGetCurrentOperator(hLine,&sOperator);

	if(0 == lReturn)
	{
		TCHAR	szInfo[MAX_PATH];
		int		nItem;
		CString	strEntry;

		if(sOperator.dwValidFields & LINEOPFORMAT_ALPHALONG)
		{
			strEntry.Format(TEXT("Current"));

			nItem	= pList->InsertItem(pList->GetItemCount(),strEntry,0);

			if(sOperator.dwValidFields & LINEOPFORMAT_NUMERIC)
				wsprintf(szInfo,TEXT("%s (%s)"),sOperator.lpszLongName,sOperator.lpszNumName);
			else
				wsprintf(szInfo,TEXT("%s"),sOperator.lpszLongName);
				
			pList->SetItemText(nItem,1,szInfo);
		}
	}

	LocalFree((HLOCAL)pStatus);
	lineClose(hLine);
}

BOOL CExtTAPISampleDlg::GetLineGeneralInfo(LPLINEGENERALINFO pInfo,LPTSTR pszInfo,DWORD dwInfo,DWORD dwOffset)
{
	if(dwInfo <= 0)
		return FALSE;

	for(int i = 0; i <(signed)(dwInfo/2); ++i)
	{
		pszInfo[i]	= (char)(*((unsigned short *)(pInfo) + i + dwOffset/2));
		pszInfo[i+1]	= NULL;
	}

	return TRUE;
}