Click here to Skip to main content
15,896,450 members
Articles / Mobile Apps / Windows Mobile

Windows Mobile Remote Controller

Rate me:
Please Sign up or sign in to vote.
4.92/5 (24 votes)
28 Mar 2008CPOL4 min read 173.9K   2.8K   104  
Control your Windows Mobile device from your desktop.
#include "stdafx.h"
#include "remoteapi.h"
#include "StringConv.h"


CRemoteAPI::CRemoteAPI(void)
:	m_hDll					(NULL),
	m_pfnFindFirstFile		(NULL),
	m_pfnFindNextFile		(NULL),
	m_pfnFindAllFiles		(NULL),
	m_pfnFindClose			(NULL),
	m_pfnCreateDirectory	(NULL),
	m_pfnRemoveDirectory	(NULL),
	m_pfnMoveFile			(NULL),
	m_pfnCopyFile			(NULL),
	m_pfnWriteFile			(NULL),
	m_pfnReadFile			(NULL),
	m_pfnGetFileSize		(NULL),
	m_pfnGetDiskFreeSpaceEx	(NULL),
	m_pfnFreeBuffer			(NULL),
	m_pfnSetFilePointer		(NULL),
	m_pfnSetFileTime		(NULL)
{
	m_hDll = LoadLibrary(_T("RAPI.DLL"));
}


CRemoteAPI::~CRemoteAPI(void)
{
	if(m_hDll)
		FreeLibrary(m_hDll);
}


// CRemoteAPI::ReloadDLL
//
//		Relaods the RAPI DLL
//
BOOL CRemoteAPI::ReloadDLL()
{
	if(m_hDll != NULL)
	{
		FreeLibrary(m_hDll);

		m_pfnFindFirstFile		= NULL;
		m_pfnFindNextFile		= NULL;
		m_pfnFindAllFiles		= NULL;
		m_pfnFindClose			= NULL;
		m_pfnCreateDirectory	= NULL;
		m_pfnRemoveDirectory	= NULL;
		m_pfnMoveFile			= NULL;
		m_pfnCopyFile			= NULL;
		m_pfnWriteFile			= NULL;
		m_pfnReadFile			= NULL;
		m_pfnGetFileSize		= NULL;
		m_pfnGetDiskFreeSpaceEx	= NULL;
		m_pfnFreeBuffer			= NULL;
		m_pfnSetFilePointer		= NULL;
		m_pfnSetFileTime		= NULL;
	}

	m_hDll = LoadLibrary(_T("RAPI.DLL"));

	return m_hDll != NULL;
}


// CRemoteAPI::InitEx
//
//		Initializes the RAPI connection
//
HRESULT CRemoteAPI::InitEx(RAPIINIT *pRapiInit)
{
	HRESULT			hr = E_NOTIMPL;
	CERAPIINITEX	pfnCeRapiInitEx;

	if(!m_hDll)
		return hr;

	pfnCeRapiInitEx = (CERAPIINITEX)GetProcAddress(m_hDll, "CeRapiInitEx");
	if(pfnCeRapiInitEx)
		hr = pfnCeRapiInitEx(pRapiInit);
	return hr;
}


// CRemoteAPI::Uninit
//
//		Shuts down the RAPI connection
//
HRESULT CRemoteAPI::Uninit()
{
	HRESULT		hr;
	CERAPUNINIT	pfnCeRapiUninit;

	if(!m_hDll)
		return E_NOINTERFACE;

	pfnCeRapiUninit = (CERAPUNINIT)GetProcAddress(m_hDll, "CeRapiUninit");
	if(pfnCeRapiUninit)
		hr = pfnCeRapiUninit();
	else
		hr = E_NOINTERFACE;

	return hr;
}


HRESULT CRemoteAPI::Invoke(LPCWSTR pszDLL, LPCWSTR pszFunction, DWORD cbInput, BYTE *pInput, DWORD *pcbOutput, BYTE **ppOutput, IRAPIStream **ppIRAPIStream, DWORD dwReserved)
{
	HRESULT			hr;
	CERAPIINVOKE	pfnCeRapiInvoke;

	if(!m_hDll)
		return E_NOINTERFACE;

	pfnCeRapiInvoke = (CERAPIINVOKE)GetProcAddress(m_hDll, "CeRapiInvoke");
	if(pfnCeRapiInvoke)
		hr = pfnCeRapiInvoke(pszDLL, pszFunction, cbInput, pInput, pcbOutput, ppOutput, ppIRAPIStream, dwReserved);
	else
		hr = E_NOINTERFACE;

	return hr;
}


HANDLE CRemoteAPI::CreateFile(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
	HANDLE			hFile = NULL;
	CECREATEFILE	pfnCeCreateFile;

	if(!m_hDll)
		return NULL;

	pfnCeCreateFile = (CECREATEFILE)GetProcAddress(m_hDll, "CeCreateFile");
	if(pfnCeCreateFile != NULL)
		hFile = pfnCeCreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
	return hFile;
}


BOOL CRemoteAPI::WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
{
	BOOL	bOk = FALSE;

	if(!m_hDll)
		return FALSE;

	if(m_pfnWriteFile == NULL)
		m_pfnWriteFile = (CEWRITEFILE)GetProcAddress(m_hDll, "CeWriteFile");
	if(m_pfnWriteFile)
		bOk = m_pfnWriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
	return bOk;
}


BOOL CRemoteAPI::ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
{
	BOOL	bOk = FALSE;

	if(!m_hDll)
		return FALSE;

	if(m_pfnReadFile == NULL)
		m_pfnReadFile = (CEWRITEFILE)GetProcAddress(m_hDll, "CeReadFile");
	if(m_pfnReadFile)
		bOk = m_pfnReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
	return bOk;
}


BOOL CRemoteAPI::CloseHandle(HANDLE hHandle)
{
	BOOL			bOk = FALSE;
	CECLOSEHANDLE	pfnCeCloseHandle;

	if(!m_hDll)
		return FALSE;

	pfnCeCloseHandle = (CECLOSEHANDLE)GetProcAddress(m_hDll, "CeCloseHandle");
	if(pfnCeCloseHandle)
		bOk = pfnCeCloseHandle(hHandle);
	return bOk;
}


// CRemoteAPI::FindFirstFile
//
//		Implements the CeFindFirstFile function
//
HANDLE CRemoteAPI::FindFirstFile(LPCWSTR lpFileName, LPCE_FIND_DATA lpFindFileData)
{
	HANDLE	hFind	= INVALID_HANDLE_VALUE;

	if(m_hDll == NULL)
		return NULL;

	if(m_pfnFindFirstFile == NULL)
		m_pfnFindFirstFile = (CEFINDFIRSTFILE)GetProcAddress(m_hDll, "CeFindFirstFile");

	if(m_pfnFindFirstFile)
		hFind = m_pfnFindFirstFile(lpFileName, lpFindFileData);

	return hFind;
}


// CRemoteAPI::FindNextFile
//
//		Implements the CeFindNextFile function
//
BOOL CRemoteAPI::FindNextFile(HANDLE hFind, LPCE_FIND_DATA lpFindFileData)
{
	BOOL	bFound	= FALSE;

	if(m_hDll == NULL)
		return NULL;

	if(m_pfnFindNextFile == NULL)
		m_pfnFindNextFile = (CEFINDNEXTFILE)GetProcAddress(m_hDll, "CeFindNextFile");

	if(m_pfnFindNextFile)
		bFound = m_pfnFindNextFile(hFind, lpFindFileData);

	return bFound;
}


BOOL CRemoteAPI::FindAllFiles(LPCWSTR pszPath, DWORD dwFlags, LPDWORD lpdwFoundCount, LPLPCE_FIND_DATA ppFindDataArray)
{
	BOOL	bFound	= FALSE;

	if(m_hDll == NULL)
		return FALSE;

	if(m_pfnFindAllFiles == NULL)
		m_pfnFindAllFiles = (CEFINDALLFILES)GetProcAddress(m_hDll, "CeFindAllFiles");

	if(m_pfnFindAllFiles)
		bFound = m_pfnFindAllFiles(pszPath, dwFlags, lpdwFoundCount, ppFindDataArray);

	return bFound;
}


// CRemoteAPI::FindClose
//
//		Implements the CeFindClose function
//
BOOL CRemoteAPI::FindClose(HANDLE hFileFind)
{
	BOOL	bOk = FALSE;

	if(m_hDll == NULL)
		return FALSE;

	if(m_pfnFindClose == NULL)
		m_pfnFindClose = (CEFINDCLOSE)GetProcAddress(m_hDll, "CeFindClose");

	if(m_pfnFindClose)
		bOk = m_pfnFindClose(hFileFind);
	return bOk;
}


BOOL CRemoteAPI::DeleteFile(LPCWSTR lpFileName)
{
	BOOL			bOk = FALSE;
	CEDELETEFILE	pfnCeDeleteFile;

	if(!m_hDll)
		return FALSE;

	pfnCeDeleteFile = (CEDELETEFILE)GetProcAddress(m_hDll, "CeDeleteFile");
	if(pfnCeDeleteFile)
		bOk = pfnCeDeleteFile(lpFileName);
	return bOk;
}


BOOL CRemoteAPI::CreateDirectory(LPCWSTR pszDirName)
{
	BOOL	bOk	= FALSE;

	if(m_hDll == NULL)
		return FALSE;

	if(m_pfnCreateDirectory == NULL)
		m_pfnCreateDirectory = (CECREATEDIRECTORY)GetProcAddress(m_hDll, "CeCreateDirectory");

	if(m_pfnCreateDirectory)
		bOk = m_pfnCreateDirectory(pszDirName, NULL);

	return bOk;
}


BOOL CRemoteAPI::RemoveDirectory(LPCWSTR pszDirName)
{
	BOOL	bOk	= FALSE;

	if(m_hDll == NULL)
		return FALSE;

	if(m_pfnRemoveDirectory == NULL)
		m_pfnRemoveDirectory = (CEREMOVEDIRECTORY)GetProcAddress(m_hDll, "CeRemoveDirectory");

	if(m_pfnRemoveDirectory)
		bOk = m_pfnRemoveDirectory(pszDirName);

	return bOk;
}


BOOL CRemoteAPI::MoveFile(LPCWSTR pszOldFileName, LPCWSTR pszNewFileName)
{
	BOOL	bOk	= FALSE;

	if(m_hDll == NULL)
		return FALSE;

	if(m_pfnMoveFile == NULL)
		m_pfnMoveFile = (CEMOVEFILE)GetProcAddress(m_hDll, "CeMoveFile");

	if(m_pfnMoveFile)
		bOk = m_pfnMoveFile(pszOldFileName, pszNewFileName);

	return bOk;
}


BOOL CRemoteAPI::CopyFile(LPCWSTR pszSrcFileName, LPCWSTR pszTgtFileName, BOOL bFailIfExists)
{
	BOOL	bOk	= FALSE;

	if(m_hDll == NULL)
		return FALSE;

	if(m_pfnCopyFile == NULL)
		m_pfnCopyFile = (CECOPYFILE)GetProcAddress(m_hDll, "CeCopyFile");

	if(m_pfnCopyFile)
		bOk = m_pfnCopyFile(pszSrcFileName, pszTgtFileName, bFailIfExists);

	return bOk;
}


DWORD CRemoteAPI::GetLastError()
{
	DWORD			dwError = 0;
	CEGETLASTERROR	pfnCeGetLastError;

	if(!m_hDll)
		return 0;

	pfnCeGetLastError = (CEGETLASTERROR)GetProcAddress(m_hDll, "CeGetLastError");
	if(pfnCeGetLastError)
		dwError = pfnCeGetLastError();
	return dwError;
}


HRESULT	CRemoteAPI::GetError()
{
	HRESULT			hr = E_NOINTERFACE;
	CERAPIGETERROR	pfnCeRapiGetError;

	if(!m_hDll)
		return hr;

	pfnCeRapiGetError = (CERAPIGETERROR)GetProcAddress(m_hDll, "CeRapiGetError");
	if(pfnCeRapiGetError)
		hr = pfnCeRapiGetError();
	return hr;
}


BOOL CRemoteAPI::GetVersionEx(CEOSVERSIONINFO *pVersionInfo)
{
	CEGETVERSIONEX	pfnCeGetVersionEx;

	if(!m_hDll)
		return FALSE;

	pfnCeGetVersionEx = (CEGETVERSIONEX)GetProcAddress(m_hDll, "CeGetVersionEx");
	if(pfnCeGetVersionEx)
		return pfnCeGetVersionEx(pVersionInfo);
	return FALSE;
}


DWORD CRemoteAPI::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
{
	if(!m_hDll)
		return 0;

	if(m_pfnGetFileSize == NULL)
		m_pfnGetFileSize = (CEGETFILESIZE)GetProcAddress(m_hDll, "CeGetFileSize");

	if(m_pfnGetFileSize)
		return m_pfnGetFileSize(hFile, lpFileSizeHigh);
	return 0;
}


DWORD CRemoteAPI::SetFilePointer(HANDLE hFile, LONG lDistance, PLONG pDistanceHigh, DWORD dwMoveMethod)
{
	if(!m_hDll)
		return 0;

	if(m_pfnSetFilePointer == NULL)
		m_pfnSetFilePointer = (CESETFILEPOINTER)GetProcAddress(m_hDll, "CeSetFilePointer");

	if(m_pfnSetFilePointer)
		return m_pfnSetFilePointer(hFile, lDistance, pDistanceHigh, dwMoveMethod);
	return 0;
}


BOOL CRemoteAPI::SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FILETIME *lpLastAccessTime, const FILETIME *lpLastWriteTime)
{
	if(!m_hDll)
		return 0;

	if(m_pfnSetFileTime == NULL)
		m_pfnSetFileTime = (CESETFILETIME)GetProcAddress(m_hDll, "CeSetFileTime");

	if(m_pfnSetFileTime)
		return m_pfnSetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
	return 0;
}


BOOL CRemoteAPI::GetDiskFreeSpaceEx(LPCTSTR lpDirectoryName, 
									PULARGE_INTEGER lpFreeBytesAvailable, 
									PULARGE_INTEGER lpTotalNumberOfBytes,
									PULARGE_INTEGER lpTotalNumberOfFreeBytes)
{
	if(!m_hDll)
		return 0;

	if(m_pfnGetDiskFreeSpaceEx == NULL)
		m_pfnGetDiskFreeSpaceEx = (CEGETDISKFREESPACEEX)GetProcAddress(m_hDll, "CeGetDiskFreeSpaceEx");

	if(m_pfnGetDiskFreeSpaceEx)
	{
		CStringConv	strDir(lpDirectoryName);

		return m_pfnGetDiskFreeSpaceEx(strDir, lpFreeBytesAvailable, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes);
	}
	return 0;
}


HRESULT CRemoteAPI::FreeBuffer(LPVOID pVoid)
{
	if(!m_hDll)
		return E_FAIL;

	if(m_pfnFreeBuffer == NULL)
		m_pfnFreeBuffer = (CERAPIFREEBUFFER)GetProcAddress(m_hDll, "CeRapiFreeBuffer");

	if(m_pfnFreeBuffer)
		return m_pfnFreeBuffer(pVoid);
	return E_FAIL;
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Software Developer (Senior) Frotcom International
Portugal Portugal
I work on R&D for Frotcom International, a company that develops web-based fleet management solutions.

Comments and Discussions