radiostatedlg.cpp

Mobile Application for trackig

// RadioStateDlg.cpp : implementation file
//

#include "stdafx.h"
#include "RadioState.h"
#include "RadioStateDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

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


// CRadioStateDlg dialog
CRadioStateDlg::CRadioStateDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CRadioStateDlg::IDD, pParent)
{
	m_hIcon				= AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_hLineApp			= NULL;
	m_dwDevices			= 0;
	m_dwCellularId		= 0;
	m_dwLowAPIVersion	= 0;
	m_hCellularLine		= NULL;
	m_dwRadioState		= 0;
	m_dwRadioSupport	= 0;
	m_bRadioOff			= FALSE;
}

void CRadioStateDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CRadioStateDlg, CDialog)
	ON_WM_SIZE()

	//}}AFX_MSG_MAP
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_ONOFF, &CRadioStateDlg::OnBnClickedOnoff)
END_MESSAGE_MAP()


// CRadioStateDlg message handlers

BOOL CRadioStateDlg::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();
	}

	if(0xFFFFFFFF != m_dwCellularId)
	{
		m_hCellularLine	= OpenTAPILine(m_dwCellularId);

		if(m_hCellularLine)
		{
			lineGetEquipmentState(m_hCellularLine,&m_dwRadioState,&m_dwRadioSupport);
		}
	}

	DisplayInfo(m_dwRadioState);
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

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

long CRadioStateDlg::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 CRadioStateDlg::ShutdownTAPI()
{
	if(m_hCellularLine)
	{
		lineClose(m_hCellularLine);
	}

	if(m_hLineApp)
	{
		lineShutdown(m_hLineApp);
	}

	m_hLineApp		= NULL;
	m_hCellularLine	= NULL;
}
void CRadioStateDlg::OnDestroy()
{
	ShutdownTAPI();

	CDialog::OnDestroy();
}

DWORD CRadioStateDlg::GetCellularLineId()
{
	DWORD				dwReturn		= 0xFFFFFFFF;
	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;
}

HLINE CRadioStateDlg::OpenTAPILine(DWORD dwLineId)
{
	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);

	return hLine;
}

void CRadioStateDlg::DisplayInfo(DWORD dwState)
{
	CString		strState(TEXT("Unknown"));
	CString		strInfo;

	switch(dwState)
	{
		case LINEEQUIPSTATE_MINIMUM:	strState	= TEXT("OFF");				break;
		case LINEEQUIPSTATE_FULL:		strState	= TEXT("ON");				break;
		case LINEEQUIPSTATE_RXONLY:		strState	= TEXT("RECEIVE ONLY");		break;
		case LINEEQUIPSTATE_TXONLY:		strState	= TEXT("TRANSMIT ONLY");	break;
		case LINEEQUIPSTATE_NOTXRX:		strState	= TEXT("OFF");				break;
	}

	strInfo.Format(TEXT("Radio state is %s"),strState);

	SetDlgItemText(IDC_EQPSTATE,strInfo);

	if(LINEEQUIPSTATE_MINIMUM	== dwState		||
	   LINEEQUIPSTATE_NOTXRX	== dwState)
	{
		m_bRadioOff	= TRUE;

		GetDlgItem(IDC_ONOFF)->SetWindowText(TEXT("Turn it ON"));
	}
	else
	{
		m_bRadioOff	= FALSE;

		GetDlgItem(IDC_ONOFF)->SetWindowText(TEXT("Turn it OFF"));
	}
}
void CRadioStateDlg::OnBnClickedOnoff()
{
	if(!m_hCellularLine)
		return;

	SetCursor(LoadCursor(NULL,IDC_WAIT));

	if(m_bRadioOff)
	{
		lineSetEquipmentState(m_hCellularLine,LINEEQUIPSTATE_FULL);

		lineRegister(m_hCellularLine,LINEREGMODE_AUTOMATIC,NULL,0);
	}
	else
	{
		lineSetEquipmentState(m_hCellularLine,LINEEQUIPSTATE_MINIMUM);

		lineUnregister(m_hCellularLine);
	}

	lineGetEquipmentState(m_hCellularLine,&m_dwRadioState,&m_dwRadioSupport);
	
	DisplayInfo(m_dwRadioState);

	SetCursor(LoadCursor(NULL,IDC_ARROW));
}