Infrared Communication with your Mobile Phone

<br />
// Set the timeouts for all read and write operations<br />
<br />
COMMTIMEOUTS timeouts;<br />
<br />
VERIFY(GetCommTimeouts(m_hPort, &timeouts));<br />
<br />
timeouts.ReadIntervalTimeout         = MAXDWORD;<br />
timeouts.ReadTotalTimeoutMultiplier  = 0;<br />
timeouts.ReadTotalTimeoutConstant    = 0;<br />
timeouts.WriteTotalTimeoutMultiplier = 100;<br />
timeouts.WriteTotalTimeoutConstant   = 0;<br />
<br />
VERIFY(SetCommTimeouts(m_hPort, &timeouts));<br />

//////////////////////////////////////////////////////////////////////////
//
//  StrConv.h - Some useful functions for string conversion.
//
//  Written by Daniel Strigl [http://www.hh-system.com/danielstrigl].
//  Copyright (c) 2003-2004. All Rights Reserved.
//
//  This code may be used in compiled form in any way you desire. 
//  This file may be redistributed unmodified by any means PROVIDING 
//  it is not sold for profit without the authors written consent, 
//  and providing that this notice and the authors name is included. 
//  By the way, if the source code in this file is used in any 
//  application I would appreciate and enjoy hearing about them. 
//
//  This file is provided "as is" with no expressed or implied warranty.
//  The author accepts no liability for any damage, in any form, caused
//  by this code. Use it at your own risk and as with all code expect 
//  bugs! It's been tested but I'm not perfect ;-)
//
//  Please use the contact page of my homepage to
//  report any bug, comment or suggestion.
//
//  Contact:
//  --------
//
//    Daniel Strigl [http://www.hh-system.com/danielstrigl]
//
//  History:
//  --------
//
//    21 Jul 2004 - Initial version.
//
//////////////////////////////////////////////////////////////////////////

#if !defined(_STRCONV_H_)
#define _STRCONV_H_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

//////////////////////////////////////////////////////////////////////////
//
//  CBSTRtoT
//
//      BSTR to CString conversion.
//
class CBSTRtoT : public CString
{
public:
	CBSTRtoT(BSTR bstr) : CString(bstr == NULL ? L"" : bstr) 
	{}
};

//////////////////////////////////////////////////////////////////////////
//
//  CTtoA
//
//      LPCTSTR to LPCSTR conversion.
//
class CTtoA
{
	LPSTR m_psz;
	
public:
	CTtoA(LPCTSTR ptsz) : m_psz(NULL)
	{
		ASSERT(ptsz != NULL);
		ASSERT(AfxIsValidString(ptsz));
#if defined(_UNICODE) // for UNICODE build
    	const int size = WideCharToMultiByte(CP_ACP, 0, ptsz, -1, 
			NULL, 0, NULL, NULL);
#ifdef _DEBUG
        if (size == 0) {
			ASSERT(!_T("Function \"WideCharToMultiByte\" failed."));
        }
#endif // _DEBUG
		ASSERT(size > 0);
		m_psz = (LPSTR) malloc(sizeof(CHAR)*size);
		ASSERT(m_psz != NULL);
		ASSERT(AfxIsValidAddress(m_psz, sizeof(CHAR)*size, TRUE));
#ifdef _DEBUG
        memset(m_psz, 0, sizeof(CHAR)*size);
#endif // _DEBUG
		VERIFY(WideCharToMultiByte(CP_ACP, 0, ptsz, -1, 
			m_psz, size, NULL, NULL) != 0);
#else // for non-UNICODE build
		m_psz = _strdup(ptsz);
		ASSERT(m_psz != NULL);
#endif // defined(_UNICODE)
		ASSERT(AfxIsValidString(m_psz));
	}

    CTtoA(const CTtoA& rhs) : m_psz(_strdup(rhs.m_psz))
	{
		ASSERT(m_psz != NULL);
		ASSERT(AfxIsValidString(m_psz));
	}

    CTtoA& operator=(const CTtoA& rhs)
	{
        if (this != &rhs)
		{
			free(m_psz);
			m_psz = _strdup(rhs.m_psz);
    		ASSERT(m_psz != NULL);
	    	ASSERT(AfxIsValidString(m_psz));
		}
		return *this;
	}

	~CTtoA()
	{
		free(m_psz);
	}

	size_t GetLength() const { return strlen(m_psz); }

	operator LPCSTR() const { return m_psz; }
};

//////////////////////////////////////////////////////////////////////////
//
//  CTtoW
//
//      LPCTSTR to LPCWSTR conversion.
//
class CTtoW
{
	LPWSTR m_pwsz;
	
public:
	CTtoW(LPCTSTR ptsz) : m_pwsz(NULL)
	{
		ASSERT(ptsz != NULL);
		ASSERT(AfxIsValidString(ptsz));
#if defined(_UNICODE) // for UNICODE build
		m_pwsz = _wcsdup(ptsz);
		ASSERT(m_pwsz != NULL);
#else // for non-UNICODE build
    	const int size = MultiByteToWideChar(CP_ACP, 0, ptsz, -1, NULL, 0);
#ifdef _DEBUG
        if (size == 0) {
			ASSERT(!_T("Function \"MultiByteToWideChar\" failed."));
        }
#endif // _DEBUG
		ASSERT(size > 0);
		m_pwsz = (LPWSTR) malloc(sizeof(WCHAR)*size);
		ASSERT(m_pwsz != NULL);
		ASSERT(AfxIsValidAddress(m_pwsz, sizeof(WCHAR)*size, TRUE));
#ifdef _DEBUG
        memset(m_pwsz, 0, sizeof(WCHAR)*size);
#endif // _DEBUG
		VERIFY(MultiByteToWideChar(CP_ACP, 0, ptsz, -1, m_pwsz, size) != 0);
#endif // defined(_UNICODE)
		ASSERT(AfxIsValidString(m_pwsz));
	}

    CTtoW(const CTtoW& rhs) : m_pwsz(_wcsdup(rhs.m_pwsz))
	{
		ASSERT(m_pwsz != NULL);
		ASSERT(AfxIsValidString(m_pwsz));
	}

    CTtoW& operator=(const CTtoW& rhs)
	{
        if (this != &rhs)
		{
			free(m_pwsz);
			m_pwsz = _wcsdup(rhs.m_pwsz);
    		ASSERT(m_pwsz != NULL);
	    	ASSERT(AfxIsValidString(m_pwsz));
		}
		return *this;
	}

	~CTtoW()
	{
		free(m_pwsz);
	}

	size_t GetLength() const { return wcslen(m_pwsz); }

	operator LPCWSTR() const { return m_pwsz; }
};

//////////////////////////////////////////////////////////////////////////

#endif // !defined(_STRCONV_H_)

void CLmsPPCDoc::OnSend()
{
	// TODO: Add your command handler code here

	LOGMARKER(_T("CLmsPPCDoc::OnSend"));

    ProcessMessages();

	CWaitStatusBar wsb(_T("Übertragung läuft..."));

	BeginWaitCursor();

	LOGNOTIFY(_T("Try to save measure data to memory stream."));

	// Create the XML document

	CComPtr<MSXML::IXMLDOMDocument> pDoc;

    HRESULT hResult = pDoc.CoCreateInstance(MSXML::CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER);

	if (FAILED(hResult) || pDoc == NULL)
	{
		EndWaitCursor();

        LOGERROR(_T("The function \"CComPtr<MSXML::IXMLDOMDocument>::CoCreateInstance\" failed; ")\
			_T("could't create XML document."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
	}

	if (pDoc->put_preserveWhiteSpace(VARIANT_TRUE) != S_OK)
	{
		pDoc = NULL; // Release the COM object before we display the error message

		EndWaitCursor();

        LOGERROR(_T("The function \"IXMLDOMDocument::put_preserveWhiteSpace\" failed; ")\
			_T("could't set \"PreserveWhitespace\" property."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
	}

	// Create the processing instruction node

	CComPtr<MSXML::IXMLDOMProcessingInstruction> pProcInst;

	if (pDoc->createProcessingInstruction(CComBSTR(L"xml"),
        CComBSTR(L"version='1.0' encoding='UTF-8'"), &pProcInst) != S_OK ||
		pProcInst == NULL)
	{
		pDoc = NULL; // Release the COM object before we display the error message

		EndWaitCursor();

        LOGERROR(_T("The function \"IXMLDOMDocument::createProcessingInstruction\" failed; ")\
			_T("could't create processing instruction."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
	}

	if (pDoc->appendChild(pProcInst, NULL) != S_OK)
	{
		pDoc = NULL; // Release the COM object before we display the error message

		EndWaitCursor();

        LOGERROR(_T("The function \"IXMLDOMDocument::appendChild\" failed; ")\
			_T("could't add processing instruction to XML document."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
	}

    // Save the measure data to the XML document

    if (!m_measureData.SaveAsXML(pDoc))
    {
		pDoc = NULL; // Release the COM object before we display the error message

		EndWaitCursor();

   		LOGERROR(_T("The function \"CMeasureData::SaveAsXML\" failed; ")\
     		_T("could't add measure data to XML document."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
    }

	// Send the XML file via IrDA to the HOST

    CComPtr<IStream> pStream;
    
	if (::CreateStreamOnHGlobal(NULL, TRUE, &pStream) != S_OK || pStream == NULL)
	{
		pDoc = NULL; // Release the COM object before we display the error message

		EndWaitCursor();

   		LOGERROR(_T("The function \"::CreateStreamOnHGlobal\" failed; ")\
     		_T("could't create stream object to save XML document."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
    }

	if (pDoc->save(CComVariant(pStream.p)) != S_OK)
    {
		pStream = NULL; // Release the COM objects before we display the error message
		pDoc = NULL;

		EndWaitCursor();

        LOGERROR(_T("The function \"IXMLDOMDocument::save\" failed; ")\
			_T("could't save XML document."));

        AfxMessageBox(_T("Das für den Datentransfer benötigte XML Dokument ")\
			_T("konnte nicht erstellt werden."), MB_OK | MB_ICONWARNING);

        return;
    }

	LOGNOTIFY(_T("Saved measure data successfully to memory stream."));

	EndWaitCursor();

    CIrObexDlg dlg(pStream.p, 
		m_measureData.GetDescription().Left(CIrObexDlg::MAX_NAME_LENGTH - 4) 
		+ _T(".lms"));

	const int nError = dlg.DoModal(); // Open the OBEX dialog

	if (nError != CIrObexDlg::EOk && nError != CIrObexDlg::EAbort)
	{
		AfxMessageBox(CIrObexDlg::GetErrorMessage(nError), 
			MB_OK | MB_ICONWARNING);
	}
}