Categories: Open C (Português) | S60 (Português) | Lang-PT

This page was last modified 21:26, 26 October 2007.

From Forum Nokia Wiki

Original: Communication options between Open C engine and S60 UI

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

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