Como usar CeRapiInvoke()

IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.

Clique aqui para ver a versão em Inglês deste artigo: 299891
Este artigo foi arquivado. É oferecido "como está" e não será mais atualizado.
Sumário
O CeRapiInvoke() API (RAPI) remota permite que você chamar as rotinas no dispositivo Windows CE de um aplicativo da área de trabalho. As rotinas são implementadas em uma DLL e a DLL devem exportar essas rotinas. Você pode usar CeRapiInvoke() de duas maneiras: no modo de bloco ou no modo de fluxo. Este artigo demonstra como usar CeRapiInvoke() em ambas as direções.
Mais Informações
A seguir está um protótipo para CeRapiInvoke em RAPI.dll a ser usado por um aplicativo em execução na área de trabalho.

HRESULT CeRapiInvoke(LPCWSTR pDllPath, LPCWSTR pFunctionName,DWORD cbInput, BYTE *pInput, DWORD *pcbOutput,BYTE **ppOutput, IRAPIStream **ppIRAPIStream,DWORD dwReserved) 				

CeRapiInvoke() será chamado no modo de bloqueio se IRAPIStream ** é NULL. Caso contrário, ele será chamado no modo de fluxo.

A seguir está um protótipo de rotina DLL executado no dispositivo:
int CallMyFunction(DWORD cbInput, BYTE* pInput,                   DWORD* pcbOutput, BYTE** ppOutput,                   IRAPIStream* pStream) 				

Usando CeRapiInvoke() no modo de bloco

No modo de bloco, chamadas para CeRapiInvoke() retornam somente depois que a rotina DLL foi executado e retornado. O ponteiro ppOutput deve ser alocado pela DLL por meio do uso de LocalAlloc() e o aplicativo da área de trabalho deve chamar LocalFree() no mesmo [ que ?]. No modo de bloqueio, ppIRAPIStream deve ser definido como NULL. O valor retornado pela rotina DLL será retornado por CeRapiInvoke.

O seguinte código de exemplo demonstra o uso de CeRapiInvoke() no modo de bloco chamando um método na DLL reside na pasta \Windows do dispositivo. O método DLL retorna a memória física disponível no dispositivo em quilobytes.
// test console application to call in blocking mode#include <windows.h>#include <stdio.h>#include <conio.h>#include "rapi.h"int main(int argc, char* argv[]){	DWORD	cbOut;	BYTE*	pOut;	HRESULT	hr;//Initialize Windows CE RAPI    hr = CeRapiInit();//Invoke CallMyFunction routine in MyRapi DLL in the \Windows directory.    hr = CeRapiInvoke(L"MyRapi", L"CallMyFunction",         0, NULL, &cbOut, &pOut, NULL, 0);	if(cbOut)		printf("Your device got %s KB of Physical Memory available", pOut);	else		printf("No memory available in the device");//Uninitialize Windows CE RAPI    hr = CeRapiUninit();//Free the DLL allocated memory.	if(pOut)		LocalFree(pOut);	return 0;}				

O código a seguir mostra a implementação da rotina CallMyFunction dentro MyRapi.dll:
#include <windows.h>#include "rapi.h"extern "C"{	__declspec(dllexport) int CallMyFunction(DWORD cbInput,		BYTE* pInput, DWORD* pcbOutput, BYTE** ppOutput,		IRAPIStream* pStream);}int CallMyFunction(DWORD cbInput, BYTE* pInput,                   DWORD* pcbOutput, BYTE** ppOutput,                   IRAPIStream* pStream){	MEMORYSTATUS structMemStatus;	DWORD dwMemAvailPhys;	char	szFree[10];	//Initialize buffer to all NULLs	ZeroMemory(szFree, 10);	GlobalMemoryStatus(&structMemStatus);	dwMemAvailPhys = structMemStatus.dwAvailPhys;	sprintf(szFree, "%d", dwMemAvailPhys/1024);	//Provide extra char for NULL	*ppOutput = (BYTE*)LocalAlloc(LPTR, strlen(szFree)+1);	if(*ppOutput)	{		//Copy along with NULL		strncpy((char*)*ppOutput, szFree, strlen(szFree)+1);		*pcbOutput = strlen(szFree) + 1;	}	else		*pcbOutput = 0;	return 0;}				

Usando CeRapiInvoke no modo de fluxo

O código a seguir demonstra como usar CeRapiInvoke() no modo de fluxo. Ele se comunica com o dispositivo por meio de interface IRAPIStream e exibe a memória física disponível em um controle de edição. Este aplicativo simples será loop indefinidamente ao ler dados do fluxo de RAPI até que uma tecla é pressionada. Depois que uma tecla é pressionada, o aplicativo sai do loop e grava o fluxo RAPI, notificando-o código no MyRapi.dll que está sendo encerrado.
// test console application to call in stream mode// #define UNICODE#define _UNICODE#include <windows.h>#include <stdio.h>#include <conio.h>#include <tchar.h>#include "rapi.h"//Serious Error conditions and execution paths are not//considered in this example. Purpose is just to demonstrate//the usage of CeRapiInvoke() in Stream mode.struct MY_MEM_STRUCT{	DWORD	dwPhysMemAvail;	DWORD	dwPhysTotal;}; int main(int argc, char* argv[]){	IRAPIStream *pStream;	DWORD	cbOut;	DWORD	dwLength, cbBytesRead;	MY_MEM_STRUCT	structMyDeviceMem;	HRESULT	hr = CeRapiInit();	hr = CeRapiInvoke(L"MyRapi", L"CallMyFunction", NULL,		NULL, &cbOut, NULL, &pStream, 0);	_tprintf(_T("Press any key to exit\n"));	fflush(stdin);	while(!kbhit())	{		cbBytesRead = 0;		//First read the length information.		hr = pStream->Read(&dwLength, sizeof(DWORD), &cbBytesRead);		if(FAILED(hr) || (dwLength != sizeof(MY_MEM_STRUCT)))		{			_tprintf(_T("Error while reading from stream"));			break;		}		//Read the bytes into the structure.		hr = pStream->Read(&structMyDeviceMem, dwLength,			&cbBytesRead);		if(FAILED(hr)) 		{			break;		}		if(cbBytesRead > 0)		{						_tprintf(_T("\rTotal Physical Memory = %d KB, Available Memory = %d KB."),				structMyDeviceMem.dwPhysTotal, structMyDeviceMem.dwPhysMemAvail);		}		Sleep(2000);	}	fflush(stdin);	DWORD	dwDataWrite = 1 ;	DWORD	cbWritten;	hr = pStream->Write(&dwDataWrite, sizeof(dwDataWrite), &cbWritten);	hr = CeRapiUninit();	return 0;}				

No dispositivo um thread separado é dedicado para ler a notificação da área de trabalho. A operação de leitura irá bloquear o thread até que ele lê a notificação do fluxo. O thread principal grava o fluxo de cada dois segundos.
struct MY_MEM_STRUCT{	DWORD	dwPhysMemAvail;	DWORD	dwPhysTotal;};UINT MyThreadProc(LPVOID pParam);CRITICAL_SECTION	g_structCriticalSect;BOOL	g_fContinue = TRUE;HRESULT	SendToMyRapiStream(IRAPIStream* pStream, 			void*	pWriteStruct, int nDataWrite){	HRESULT hr;	DWORD	cbWritten, dwWrite;	dwWrite = sizeof(nDataWrite);	//Write the length information first	hr = pStream->Write(&nDataWrite, dwWrite, &cbWritten);	if(FAILED(hr))		return E_FAIL;	//Write the structure into the stream	hr = pStream->Write(pWriteStruct, nDataWrite, &cbWritten);	if(FAILED(hr))		return E_FAIL;	return S_OK;}int CallMyFunction(DWORD dwInput, BYTE* pInput,                   DWORD* pcbOutput, BYTE** ppOutput,                   IRAPIStream* pStream){	MEMORYSTATUS structMemStatus;	BOOL	bContinue = TRUE;	MY_MEM_STRUCT	structMyMem;	HRESULT	hr;		DWORD	dwThreadId;	InitializeCriticalSection(&g_structCriticalSect);	HANDLE hThread = CreateThread(NULL, NULL,		(LPTHREAD_START_ROUTINE)MyThreadProc, pStream,		NULL, &dwThreadId);	while(1)	{		EnterCriticalSection(&g_structCriticalSect);		if(g_fContinue == FALSE)		{			LeaveCriticalSection(&g_structCriticalSect);			break;		}		LeaveCriticalSection(&g_structCriticalSect);		GlobalMemoryStatus(&structMemStatus);		structMyMem.dwPhysMemAvail = structMemStatus.dwAvailPhys / 1024;		structMyMem.dwPhysTotal = structMemStatus.dwTotalPhys / 1024;		hr = SendToMyRapiStream(pStream, &structMyMem, sizeof(structMyMem));		if(FAILED(hr))		{			break;		}                  /*wait for 2 seconds. if WaitForSingleObject() comes out		in less than 2 seconds then client has requested to stop		sending the data or an error has occured.*/ 		if(WaitForSingleObject(hThread, 2000) != WAIT_TIMEOUT)			break;	}	//Make sure the other thread has terminated	WaitForSingleObject(hThread, 5000);	DeleteCriticalSection(&g_structCriticalSect);	g_fContinue = FALSE;         return 0;	}UINT MyThreadProc(LPVOID pParam){	DWORD	dwInput, cbReadBytes;	IRAPIStream* pStream = (IRAPIStream*)pParam;	HRESULT hrStream = pStream->Read(&dwInput, sizeof(dwInput), &cbReadBytes);	EnterCriticalSection(&g_structCriticalSect);	g_fContinue = FALSE;	LeaveCriticalSection(&g_structCriticalSect);	return 0;}				
para obter informações adicionais, consulte a referência de função CeRapiInvoke MSDN:

Módulos de criação que usam RAPI

O arquivo de cabeçalho Rapi.h e arquivo de biblioteca Rapi.lib estão disponíveis para uso em compilar e vincular o código da área de trabalho para usar a RAPI. O arquivo de cabeçalho e arquivos de biblioteca para uso com funções RAPI são encontrados no seguinte pasta em uma instalação típica:
C:\Windows CE Tools\wce300\MS Pocket PC\support\ActiveSync\Inc
C:\Windows CE Tools\wce300\MS Pocket PC\support\ActiveSync\Lib
Para compilar a DLL do lado do dispositivo, você pode usar o mesmo arquivo Rapi.h mencionado anteriormente. Não há nenhum arquivo de biblioteca RAPI necessárias para criar o dispositivo DLL.

Observação: RAPI.dll não é redistribuível. Ele é instalado quando o ActiveSync é instalado no computador host da área de trabalho.

Aviso: este artigo foi traduzido automaticamente

Propriedades

ID do Artigo: 299891 - Última Revisão: 12/06/2015 02:55:31 - Revisão: 1.5

Microsoft Windows CE 2.12 para o Handheld PC, Microsoft Windows CE 2.11 para Handheld PC, Microsoft Windows CE 2.0 for the Handheld PC, Microsoft Windows CE 3.0 para Handheld PC

  • kbnosurvey kbarchive kbmt kbhowto KB299891 KbMtpt
Comentários