×
Namespaces

Variants
Actions

Opções de comunicação entre máquina Open C e S60 UI

From Nokia Developer Wiki
Jump to: navigation, search
Article Metadata

Compatibilidade
Plataforma(s):
Symbian

Artigo
Tradução:
Por kyllercg
Última alteração feita por hamishwillee em 08 May 2013


Contents

Introdução

Este artigo examina as diferente maneiras de combinar as funcionalidade Open C com uma aplicação S60. Dependendo da quantidade de funcionalidade e dos tipos de dados pode-se escolher incluir o código Open C diretamente na aplicação S60 ou criar um novo binário. O binário Open C pode ser um executável separado que executa como um processo independente ou uma biblioteca que é usada pela aplicação S60.

Funcionalidade Open C em um processo separado

IPC.png

Dependendo do tipo da funcionalidade que o componente Open C prove, existem diversas formas de projetar a comunicação (IPC) entre os processos.

// Constantes usadas nos examplos
 
_LIT(KNoName, "");
_LIT(KTxtPanic,"Panic");
_LIT(KEngineName, “MyEngine.exe”);
 
#define KQueueIndex 10
#define KChunkIndex 11
#define KMutexIndex 12
#define KMemSize 1024

1) Inicie o processo e espere até o término

/**
* Aplicação S60 UI
*/
void CMyClass.CallEngineL(const TDesC &aCommandLine)
{
TRequestStatus status;
RProcess process;
 
User::LeaveIfError(process.Create(KEngineName, aCommandLine));
process.Logon(status);
process.Resume();
 
User::WaitForRequest(status); // espera até que o processo termine
process.Close();
}
/**
* Máquina Open C
*/
int main(int argc, char* argv[])
{
// CÓDIGO DA MÁQUINA
}

2) Troque informações entre os processos que estão executando

Se existir um fluxo contínuo de dados entre os processos um canal deve ser criado. Para tratar o canal de comunicação um camada de código Symbian é adicionado no topo do código Open C. A função main() é substituída pela função E32Main().

/**
* Novo ponto de entrada
*/
LOCAL_C void OpenCMainL(TPtrC &aCommandLine)
{
// ENGINE CODE
}
/**
* Um executável Symbian OS normal prove uma função E32Main() que é chamada
* pelo sistema operacional para iniciar o programa.
*/
GLDEF_C TInt E32Main()
{
CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack
 
// executa o código
RProcess process;
TRAPD(error,OpenCMainL(process.CommandLine()));
 
__ASSERT_ALWAYS(!error,User::Panic(KTxtPanic, error));
 
delete cleanup; // destroi pilha de limpeza
return 0;
}

2.1) Usando a fila de mensagens

Código da aplicação S60

// Dados do membros
RProcess iProcess;
RMsgQueue<TInt32> iQueue;
// Initialização
User::LeaveIfError(iQueue.CreateGlobal(KNoName, 1);
User::LeaveIfError(iProcess.Create(KEngineName, aCommandLine));
 
iProcess.SetParameter(KQueueIndex, iQueue);
iProcess.Resume();
// Engine update
TInt32 msg;
iQueue.ReceiveBlocking(msg);
// Finalização
iProcess.Kill(KErrNone);
iQueue.Close();
iProcess.Close();

Código Open C

#include <e32std.h>
#include <e32base.h>
#include <e32cons.h>
#include <e32msgqueue.h>
 
LOCAL_C void OpenCMainL(TPtrC &aCommandLine)
{
RMsgQueue<TInt32> queue;
User::LeaveIfError(queue.Open(KQueueIndex));
 
while ( ... )
{
...
// Atualizar processo S60 UI
TInt32 msg;
queue.SendBlocking(msg);
}
queue.Close();
}

2.2) Usando memória global

Código da aplicação S60 UI

// Data members 
RProcess iProcess;
RChunk iChunk;
RMutex iMutex;
// Initialization
User::LeaveIfError(iChunk.CreateGlobal(KNoName, KMemSize, KMemSize));
User::LeaveIfError(iMutex.CreateGlobal(KNoName));
User::LeaveIfError(iProcess.Create(KEngineName, aCommandLine));
 
iProcess.SetParameter(KChunkIndex, iChunk);
iProcess.SetParameter(KMutexIndex, iMutex);
 
iProcess.Resume();
// Engine update
iMutex.Wait();
unsigned char* ptr = iChunk.Base(); // Get global memory base address
...
iMutex.Signal();
// Finalization
iProcess.Kill(KErrNone);
iMutex.Close();
iChunk.Close();
iProcess.Close();

Código Open C

#include <e32std.h>
#include <e32base.h>
#include <e32cons.h>
 
LOCAL_C void OpenCMainL(TPtrC &aCommandLine)
{
RChunk chunk;
RMutex mutex;
 
User::LeaveIfError(chunk.Open(KChunkIndex));
User::LeaveIfError(mutex.Open(KMutexIndex));
 
while ( ... )
{
...
// Update UI process
mutex.Wait();
unsigned char* ptr = chunk.Base(); // Get global memory base address
...
mutex.Signal();
}
chunk.Close();
mutex.Close();
}

Funcionalidade Open C em uma biblioteca

Funcionalidade Open C dentro do binário da aplicação

This page was last modified on 8 May 2013, at 02:58.
92 page views in the last 30 days.