Symbian C++ vs .NET Compact Framework C#

1. Symbian C++ vs.NET Compact Framework C# Leonardo Kunz

2. Sumário • Introdução (Symbian OS) • Características • História • Symbian C++ vs .NET Compact C# • Convenções • Exceções • Objetos ativos • Threads • Sincronização • Conclusões

3. Symbian OS - Introdução • Características Principais • SO para dispositivos móveis e PDAs • Desenvolvido para arquitetura ARM • Ênfase na economia de recursos • Suporte para aplicações de tempo real • Multitarefas e proteção de memória • Equipa maioria dos smartphones atuais • Várias plataformas (S60, UIQ, MOAP)

4. Symbian OS - Introdução • História • Ericsson, Nokia, Motorola e Psion fundaram a Symbian Ltd. em 1998 • Baseado no EPOC da Psion • Symbian Ltd. desenvolve SO base e licencia para fabricantes • Em 24 de junho de 2008, anuncia compra da Symbian e criação da Symbian Foundation

5. Symbian OS - Introdução • Symbian Foundation • Unificar plataformas Symbian • Tornar plataforma open-source • Parceiros: Nokia, Sony Ericsson, Motorola, NTT DoCoMo, AT&T, LG Electronics, Samsung Electronics, STMicroelectronics, Texas Instruments e Vodafone

6. Symbian OS - Introdução • Linguagens suportadas • Symbian C/C++ • JavaME • FlashLite • Perl • Python • Ruby • Lua

7. Symbian C++ • Baseada em C++ • Otimizada para dispositivos móveis com recursos limitados • Principais características • CleanupStack • Trap/Leave • Modelo cliente/servidor – chamadas assíncronas • Objetos ativos

8. Symbian C++ - Convenções • Conveção de Nomes - baseada na funcionalidade das classes • Classes T • Classes C • Classes R • Classes M

9. Symbian C++ - Convenções • Classes Tipo T • Normalmente alocadas na pilha • Desalocadas quando função de chamada retornar

10. Symbian C++ - Convenções • Classes Tipo C • Alocadas em heap • Sempre derivam da classe CBase • Operador new • Manipuladas por ponteiro

11. Symbian C++ - Convenções • Classes Tipo R • Handles para recursos mantidos em outro lugar

12. Symbian C++ - Convenções • Classes Tipo M • Definem classes abstratas • Implementação em classes derivadas

13. .NET Compact Framework • Baseado no .NET • Desenvolvimento para Windows CE • C# ou Visual Basic

14. Symbian C++ - Exceções • Try / Catch do C++ não suportado em versões anteriores à versão 9.0 • Mecanismo Leave / Trap é semelhante • Menor overhead • Métodos com Leave devem terminar em L

15. Symbian C++ - Exceções int InsertL(){//... other codes ...if (!myObject) User::Leave(KErrNoMemory);//... more codes...} TInt errcode;TRAP(errcode, InsertL()); if (errcode == KErrNoMemory){ // threats exceptions throwed by "InsertL()"}

16. Symbian C++ - Exceções • Sinalização de erros fatais – Panic • User::Panic(). • Resulta na finalização da thread

17. .NET Compact C# - Exceções • Try / Catch / Finally • Idêntico à .NET • Mais legível do que mecanismo de exceções (Trap / Leave) do Symbian

18. Symbian C++ - Objetos Ativos • Modelo baseado em eventos • Objetos Ativos fazem chamadas assíncronas e se preemptam • Escalonador Ativo aciona execução • Menor overhead do que threads • Sincronização não é necessária

19. Symbian C++ - Objetos Ativos

20. Symbian C++ - Threads • Classe RThread provê funcionalidade das threads • Criadas através da instanciação da classe RThread e do método create() • Método resume() inicia execução • Estados: running, ready, waiting, e suspended • Método kill() finaliza thread

21. Symbian C++ - Threads Criando uma thread: RThread thread; thread.Create(KThreadName, threadFunction, 4096, KMinHeapSize, 256*KMinHeapSize, &iParameter); thread.Resume();

22. .NET Compact C# - Threads • Semelhante ao Symbian • Desenvolvedor deve controlar finalização das threads - comando abort() Thread myThread = new Thread(new ThreadStart(MyThread)); myThread.Start();

23. Symbian C++ - Sincronização • Semáforos • Wait() e Signal() • Classe RSemaphore • Locais ou globais • Mutex • Wait() e Signal() • Classe RMutex • Locais ou globais

24. Symbian C++ - Sincronização • Seções críticas • Região do código em que apenas uma thread pode entrar por vez • Classe RCriticalSection • Wait() e Signal() • IsBlocked()

25. Symbian C++ - Sincronização 1: class CMessageBuffer 2: { 3: public: 4: CMessageBuffer(); 5: void AddMessage(const TDes &aMsg); 6: void GetMessages(TDes &aMsgs); 7: 8: public: 9: RMutex iMutex; 10: TDes iMsgs; 11: }; 12: 13: CMessageBuffer::CMessageBuffer() 14: { 15: iMutex.CreateLocal(); 16: } 17: 18: void CMessageBuffer::AddMessage(const TDes &aMsg) 19: { 20: iMutex.Wait(); 21: iMsgs.Append(aMsg); 22: iMutex.Signal(); 23: }

26. Symbian C++ - Sincronização 25: void CMessageBuffer::GetMessages(TDes &aMsgs) 26: { 27: iMutex.Wait(); 28: aMsg.Copy(iMsgs); 29: iMsgs.Zero(); 30: iMutex.Signal(); 31: } 32: 33: static void CMyClass::threadFunction(TAny *aPtr) 34: { 35: CMessageBuffer *msgBuffer = (CMessageBuffer *)TAny; 36: TInt count = 0; 37: TBuf<40> msg; 38: 39: while (TRUE) 40: { 41: msg.Format(“ID: %d, count: %d\n”, RThread().Id(), count++); 42: msgBuffer->AddMessage(msg); 43: User::After(1000 * 1000); 44: } 45: }

27. .NET Compact C# - Sincronização • Mutex • Mutex.WaitOne • Mutex.Release • Monitores • Monitor.Enter(this); • Monitor.Exit(this); • Interlocked • Interlocked.Increment(ref counter); • Interlocked.Decrement(ref counter);

28. Conclusões • Múltiplas plataformas dificultam a portabilidade de código • Documentação das APIs é pouco detalhada • Não possui monitores • Programação com modelos não usuais (Ex. Trap/Leave e Objetos Ativos)

29. Bibliografia • Symbian OS - http://en.wikipedia.org/wiki/Symbian_OS • Symbian.com - http://www.symbian.com/ • NewLC - http://www.newlc.com/ • Symbian Developer Network - http://developer.symbian.com/main/index.jsp • Forum Nokia - http://www.forum.nokia.com/ • Symbian Tutorial - http://www.symbiantutorial.org/ • .NET Compact Framework Documentation - http://msdn.microsoft.com/en-us/library/ms950380.aspx