TV Digital e JavaTV

Como alguns devem saber a TV Digital de alta definição (HDTV) foi lançada oficialmente no Brasil neste domingo dia 02 de Dezembro, porém ainda tem muito pra ser feito, alterado, e para termos um sistemas 100% HD vai demorar alguns anos, segundo as próprias emissoras, prevendo custos e a própria tecnologia interna, isso sem contar é claro a massa da população brasileira, que deverá se adaptar para tal.

O padrão para a transmissão adotado pelo governo, que encabeçou essa migração, para TV Digital foi o Japonês. Este sistema japonês segundo as emissoras, é mais robusto, e por isso foi o escolhido. Contudo, a transmissão é apenas uma parte da infra-estrutura necessária, existem várias outras coisas envolvidas, como citado abaixo:

• Gravação - exige equipamentos especiais e diferentes da parafernalha que existe hoje nas emissoras.
  
• Codificação - O padrão adotado aqui no Brasil, foi o MPEG-4 (primeiro no mundo a adotar este padrão), melhor do que o padrão mundial que é o MPEG-2.
  
• Multiplexação - Equipamentos mais robustos, terão que ser empregados, sendo que será necessário empacotar junto, uma imagem maior, um som com mais qualidade (podendo até´ser um Surround 5.1) e os programas de interatividade.
  
• Transmissão - Aqui que entra a tecnologia japonesa de transmissão, o tal do ISDB.
  
• Recepção - As TVs estão prontas para decodificar sinais UHF normais, e isso é um problema que será resolvido com um outro decodificador.

Mas existe uma boa notícia para nós desenvolvedores, um novo nicho de mercado está se abrindo aqui no brasil. A plataforma Java, já há anos disponibiliza uma api para se trabalhar com tais coisas, a JavaTV, a qual é construída em cima da tecnologia JME. Esta nova API, requer sobretudo conhecimento nas tecnologias de transmissão de dados, na API JMF (Java Media Framework) e nas tecnologias de codificação de imagens como é o caso da MPEG.

Para quem não conhece a tecnologia JME, vai aqui uma breve explicação sobre ela. A tecnologia JME, é subdividida em Configuration e Profile. Em configuration, podemos encontrar o tal do CLDC que é o que existe em celulares hoje, e o CDC, que é uma configuration mais avançado, que roda em equipamentos mais avançados, como PDAs e os tais dos SET-TOP Boxes, que para quem sempre ficou curioso em saber o que é, é o tal do aparelhinho de TV. Já em Profiles encontramos o MIDP que é encontrado nos celulares e roda em cima do CLDC, e outros profiles como o Personal Profile, usado nestes equipamentos mais avançados, que roda em cima de CDC. Para quem já deu uma olhada em JME, nem que seja por curiosidade já se deparou com esta figura, que da uma explanação geral dobre a tecnologia Java. (Mais informações sobre JME ou aqui)
Agora, voltando a JavaTV API, temos a seguinte ilustração, que mostra como é a arquitetura da tal da java TV:

Como os caras que dão nomes para as coisas não costumam ser muito originais, as aplicações para JavaTV são chamadas de Xlets, seguindo a idéia das MIDlets, Servlets e Applets. =)

Tá, tá... Vamos ao que interessa. Como eu desenvolvo para essa tal de JavaTV?
Primeiro de tudo vc precisa das bibliotecas para o desenvolvimento, e uma leitura sobre o que é e para que serve cada coisa da API, e para isso um bom lugar é a Home do JavaTV.

Após uma breve leitura sobre algumas coisas, mas ainda está se perguntando, "what the hell i need?" Ok. Você irá precisar da biblioteca da JavaTV, de um emulador, e de uma IDE. Segue abaixo os links:

• XletView - emulador para aplicações Xlet
• IDE Eclipse - minha ide favorita

Bom, a princípio o que vc precisa é isso. O XletView, já vem com a lib do javaTv, assim como a do JMF e JavaAssist. Tudo o que vc precisa a princípio.

Para fazer uma aplicação e rodá-la, é bem fácil e nada fora do comum, basta seguir os passos abaixo:

1. Faça o download do XletView e Descompacte-o em qualquer diretório.
   
2. Na sua IDE, crie um novo projeto, Java (Java Project no eclipse)
3. No Build Path do projeto adicione as seguintes libs:
1. xletview-0.3.6/xletview.jar
   xletview-0.3.6/jars/javassist.jar
   xletview-0.3.6/jars/metouia.jar
   xletview-0.3.6/jars/nanoxml-2.2.3.jar
   xletview-0.3.6/JMF2.1.1/lib/customizer.jar
   xletview-0.3.6/JMF2.1.1/lib/jmf.jar
   xletview-0.3.6/JMF2.1.1/lib/mediaplayer.jar
   xletview-0.3.6/JMF2.1.1/lib/multiplayer.jar

Pronto, projeto configurado com as bibliotecas necessárias.

Antes de botarmos a mão na massa, vamos apenas conhecer um pouco da arquitetura do JME e do Xlet, apenas para desmistificar o negócio. Antes de mais nada vai uma breve explicação sobre o ciclo de vida de um Xlet.
Sendo ele, construido em cima da plataforma JME, não é de se adimirar que o ciclo de vida dele, imita aplicações construidas para celulares, ou seja em cima de MIDP (ao menos para os celulares de meros mortais, onde não roda um CDC+PP).
Como estava dizendo, o ciclo de vida é parecido com o de uma MIDlet (MIDP), para quem já conhece um pouquinho, segue uma simples comparação (paralelo):

MIDLET

1. Herança padrão: MIDlet (aqui tem que ser extends)
   
2. Ciclo de Vida
1. public void startApp() - método chamado pelo ApplicationManager para startar a aplicação
   
2. public void pauseApp() - método chamado pelo ApplicationManager para pausar a aplicação, ou pelo usuário, ou quando chega uma chamada, etc.
   
3. public void destroyApp() - método chamado assim que a aplicação vai ser destruida.
   
3. Interface de Listener de botões: CommandListener

XLET

1. Interface pdrão: Xlet (aqui é melhor, sendo apenas um implements)
2. Ciclo de vida
1. public void initXlet(XletContext) - método chamado antes de todos para inicialização dos componentes da aplicação, e a manipulação do XletContext.
   
2. public void startXlet() - método chamado para iniciar a aplicação para o usuário
   
3. public void pauseXlet() - método chamado quando houver um evento que cause uma pausa na aplicação
   
4. public void destroyXlet() - método chamado na destruição da aplicação.
   
3. Interface de Listener de botões: ActionListener (aquele do AWT)
   

Basicamente, os Xlets tem um método a mais que MIDlets, que é o initXlet. Abaixo, segue um diagrama de estados mostrando o ciclo de vida de um Xlet:

Para este post não ficar muito grande, a implementação do primeiro exemplo segue num próximo post. (em breve)

Abraços.