Professional Documents
Culture Documents
ARACAJU
2008
UNIVERSIDADE FEDERAL DE SERGIPE
DEPARTAMENTO DE COMPUTAÇÃO
CIÊNCIA DA COMPUTAÇÃO
ARACAJU
2008
UNIVERSIDADE FEDERAL DE SERGIPE
DEPARTAMENTO DE COMPUTAÇÃO
CIÊNCIA DA COMPUTAÇÃO
ARACAJU
2008
RESUMO
A televisão é um dos maiores meios de comunicação do mundo, como também é uma grande
fonte de informação, entretenimento e cultura. Com a chegada da TV Digital além dos
benefícios trazidos com a imagem e o som de alta definição, o usuário deixará de ser um mero
espectador e passará a interagir com a programação, podendo também usufruir de uma
variedade de serviços computacionais através da TV. Em 2006, o governo brasileiro criou o
SBTVD (Sistema Brasileiro de Televisão Digital), baseado no padrão Japonês. Como o
padrão brasileiro chegou depois dos internacionais, este pôde inovar utilizando tecnologias
mais recentes. Além disto, o SBTVD também inovou no seu Middleware, o Ginga, que
possibilita a execução de aplicações interativas através do ambiente de apresentação Ginga-
NCL e do ambiente de execução Ginga-J. Este trabalho traz um estudo sobre o SBTVD e seu
Middleware, um guia de desenvolvimento para aplicações na TV digital e por fim um estudo
de caso com a implementação de uma aplicação demonstrando parte do potencial desse novo
veiculo.
i
ABSTRACT
Television is one of the biggest media in the world, it is also a large source of information,
entertainment and culture. With the arrival of Digital TV than those benefits with high
definition image and sound, the user will no longer be a mere spectator and will interact with
the programming, can now also enjoy a variety of computing services through the TV.
Coordinated by the Brazilian government, was produced the SBTVD (Brazilian System
Digital Television), based on the Japanese standard. As the Brazilian standard came after the
international, this could innovate using latest technologies. In addition, the SBTVD also
innovated in its Middleware, the Ginga, which allows the execution of interactive applications
through the presentation environment Ginga-NCL and the execution environment Ginga-J.
This work brings a study on the SBTVD and its Middleware, a guide for development of
applications for digital TV and finally a case study with the implementation of an application
demonstrating part of the potential of this new vehicle.
ii
SUMÁRIO
1. INTRODUÇÃO ....................................................................................................................8
2. SISTEMA DE TELEVISÃO DIGITAL INTERATIVA ................................................10
2.1. TRANSMISSÃO NA TV DIGITAL .............................................................................10
2.2. O CONCEITO DE INTERATIVIDADE.......................................................................11
2.3. COMPONENTES DA TV DIGITAL INTERATIVA ...................................................12
2.4. ARQUITETURA DO SISTEMA DE TV DIGITAL INTERATIVA ............................13
2.4.1. Camada de aplicação ..............................................................................................13
2.4.2. Middleware.............................................................................................................14
2.4.3. Camada de Codificação e Decodificação ...............................................................15
2.4.4. Camada de Transporte ............................................................................................15
2.4.5. Camada de Transmissão e Recepção......................................................................16
2.5. PADRÕES MUNDIAIS DE TV DIGITAL INTERATIVA ..........................................16
2.5.1. ATSC - Padrão Americano.....................................................................................16
2.5.2. DVB - Padrão Europeu...........................................................................................18
2.5.3. ISDB - Padrão Japonês ...........................................................................................18
2.6. SURGIMENTO DA TV DIGITAL NO BRASIL..........................................................19
2.7. PADRÃO BRASILEIRO DE TV DIGITAL .................................................................20
2.7.1. Middleware.............................................................................................................20
2.7.2. Camada de Codificação e Decodificação ...............................................................21
2.7.3. Camada de Transporte ............................................................................................22
2.7.4. Camada de Transmissão e Recepção......................................................................22
3. O GINGA E SUA ARQUITETURA.................................................................................24
3.1. O AMBIENTE GINGA-NCL ........................................................................................25
3.1.1. Lua ..........................................................................................................................27
3.1.2. Edição em Tempo Real...........................................................................................28
3.2. O AMBIENTE GINGA-J ..............................................................................................28
3.2.1. API JavaTV ............................................................................................................30
3.2.2. API DAVIC ............................................................................................................32
3.2.3. API HAVi ...............................................................................................................32
3.2.4. API DVB ................................................................................................................33
3.3. A PONTE ENTRE O GINGA-NCL E O GINGA-J .......................................................34
iii
3.4. INOVAÇÕES DO GINGA ............................................................................................34
4. GUIA DE DESENVOLVIMENTO DE UM APLICATIVO PARA TV DIGITAL.....36
4.1. APLICAÇÕES NO AMBIENTE GINGA-NCL............................................................39
4.2. APLICAÇÕES NO AMBIENTE GINGA-J ..................................................................40
4.2.1. O ciclo de vida da Xlet ...........................................................................................40
4.2.2. Ambiente Gráfico ...................................................................................................42
5. ESTUDO DE CASO ...........................................................................................................44
5.1. SISTEMAS DE RECOMENDAÇÃO ...........................................................................44
5.2. APLICAÇÃO AUTOCANAL.......................................................................................45
6. CONCLUSÃO.....................................................................................................................48
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................49
APÊNDICE A – TUTORIAL DE DESENVOLVIMENTO DE UM APLICATIVO EM
JAVATV ..................................................................................................................................53
APÊNDICE B - CÓDIGO DE IMPLEMENTAÇÃO DA APLICAÇÃO AUTOCANAL
..................................................................................................................................................62
iv
LISTA DE FIGURAS
v
LISTA DE ABREVIATURAS
vi
MHP - Multimedia Home Platform
NCL - Nested Context Language
NTSC - National Television System Committee
OFDM - Orthogonal Frequency Division Multiplex
PAL - Phase Alternation Line
PS - Program Streams
PSK - Phase Shift Keying
QAM - Quadrature Amplitude Modulation
SBTVD - Sistema Brasileiro de televisão Digital
SDTV - Sistema de Televisão Digital
SECAM - Séquentiel Couleur Avec Memoire
STB - Set Top Box
TS - Transport Strems
TVD - TV Digital
VCEG - Video Coding Experts Group
XML - Extensible Markup Language
vii
1. INTRODUÇÃO
Esta mudança está provocando uma onda de impacto em todo o mundo como também
no Brasil. Com a tecnologia de TV Digital, há um ganho considerável em termos de resolução
da imagem (alta definição) e qualidade de som além de possibilitar a transmissão de vários
programas em um único canal. Entretanto, a principal característica da TV Digital é a
capacidade de permitir interatividade entre o usuário telespectador e a emissora de
programação.
O trabalho está dividido da seguinte forma: no capitulo dois será abordado o Sistema
Internacional de Televisão Digital, mostrando alguns conceitos sobre televisão digital, em
seguida será apresentado os padrões utilizados mundialmente e por fim mostrará como surgiu
o SBTVD e sua arquitetura utilizada. No capítulo três será mostrado o padrão de middleware
Ginga adotado com enfoque ao estudo das API (Application Programming
Interface) para o desenvolvimento das aplicações. O capitulo quatro mostrará um guia de
como desenvolver aplicações interativas para TV Digital e o capítulo cinco mostrará um
estudo de caso de um sistema de recomendação com base nesse guia. Por fim as conclusões
são apresentadas no capítulo seis.
9
2. SISTEMA DE TELEVISÃO DIGITAL INTERATIVA
Estes recursos trazem uma transmissão de melhor qualidade. Antes, para chegar até os
receptores dentro de suas casas, parte do sinal poderia sofrer interferências ou parte dele
poderia ser refletido por diversos obstáculos provocando ruídos, chuviscos e sobreposição de
imagens. O sistema digital é transmitido de forma binária (zero ou um), proporcionando um
sinal de alta qualidade de som e imagem. Na recepção do sinal digital ou o sinal chega com
10
perfeição ou não chega, caso haja interferência o sinal não será exibido. Estas transmissões
são feitas via aérea, com o uso de satélite, ou terrestre, por ondas ou cabos [SILVA, 2003].
Entretanto, alguns autores mais puristas dizem que estas formas de interatividade
ainda são meramente reativas, ou seja, reagem às opções determinadas pelo emissor.
Sugerindo a criação de mais alguns níveis de interatividade para que ela se torne pró-ativa,
possibilitando ao usuário enviar vídeos às emissoras e, desta forma, passar a contribuir com o
conteúdo transmitido. Tendo como exemplo o que acontece hoje na Internet com o advento da
Web 2.0 [MONTEZ & BECKER, 2005].
11
2.3. COMPONENTES DA TV DIGITAL INTERATIVA
O conteúdo televisivo que pode ser fluxos de áudio, vídeo ou dados são transmitidos
por milhares de estações e recebidos por aparelhos digitais de televisão ou pelos STB (Set Top
Box). Esse aparelho é responsável por fazer a conversão do sinal digitalizado para TV
analógica além de possuir um canal de retorno para fornecer a interatividade entre o emissor e
telespectador. Ele é constituído por componentes de software (sistema operacional e ambiente
que executa os programas interativos) e hardware específico [FERNANDEZ, 2004].
• Interatividade local: não utiliza o canal de retorno. Podem ser realizadas interações
como: configuração de legendas, jogos residentes e acesso ao guia de programação
eletrônica.
12
• Interatividade remota: utiliza o canal de retorno. Podem ser realizadas interações
como: comércio eletrônico, acesso a contas bancárias, serviços de saúde e aplicações
para educação à distância.
É a camada responsável pela captura e formatação dos sinais de áudio e vídeo, bem
como a execução dos aplicativos multimídias desenvolvidos. Desta forma segue uma lista de
possíveis aplicações com uma breve descrição.
13
oferecidos e escolher o que mais lhe agradar. Ele pode selecionar um canal
convencional ou resolver comprar um vídeo pré-armazenado para assistir.
• Vídeo sob demanda: o consumidor tem acesso a um acervo de vídeos que podem ser
escolhidos e apresentados sob sua demanda, na hora em que lhe for mais conveniente.
2.4.2. Middleware
14
2.4.3. Camada de Codificação e Decodificação
15
2.4.5. Camada de Transmissão e Recepção
Logo abaixo, temos a Figura 2, que representa uma visão arquitetural em camadas das
opções de padrões para um sistema de televisão digital interativa. Em seguida, nos tópicos
seguintes, estão descritos os padrões mundiais de TV Digital, identificando os componentes
básicos adotados por eles.
16
modulação 8-VSB [SPARANO, 2000]. Define dois modelos técnicos de transmissão: via
cabo (ATSC-C) e via rádio-difusão (ATSC-T), sendo o modelo de transmissão a cabo o mais
difundido. A multiplexação e codificação de vídeo são feitas sobre o padrão MPEG-2, já a
codificação de áudio é realizada através do padrão Dolby AC-3 [ATSC, 2001].
Entre os pontos positivos deste padrão está à característica de utilizar uma camada de
software em interface aberta, o DASE (DTV Application Software
Environment)[DASE, 2008]. O DASE define uma camada de software, o middleware,
no qual os receptores de outros padrões conseguem ter acesso as informações e programações
do padrão ATSC [SILVA, 2003].
17
2.5.2. DVB - Padrão Europeu
18
nos dois padrões anteriores, também são realizadas em MPEG-2, já a codificação de áudio
utiliza o MPEG-2 ACC [ISO, 1997].
É o mais novo dentre os três principais padrões e seu grande diferencial é o suporte a
múltiplos níveis de transmissão, podendo ser usado, por exemplo, para prover
simultaneamente recepção de baixa taxa de dados sob condições móveis excepcionalmente
difíceis, taxa de dados intermediária (SDTV) para recepção estática e alta taxa de dados
(HDTV) para boas condições de recepção [FERNANDEZ, 2004].
2.7.1. Middleware
20
Figura 3 - Arquitetura em camadas do SBTVD
O padrão H.264 foi desenvolvido pela ITU-T Video Coding Experts Group
(VCEG) em conjunto com a ISO/IEC MPEG que formaram uma parceria conhecida por
Joint Video Team (JVT). A versão final, formalmente chamada por ISO/IEC 14496-
10), foi lançada em Maio de 2003 [MANUEL, 2007].
21
Para compressão de áudio foi adotado o MPEG-4 AAC (Advanced Audio
Coding), também conhecido como MPEG-2 Part 7 ou MPEG-4 Part 3. Este formato é uma
evolução da Camada-3 do MPEG-1 Áudio (também denominada MP3).
O AAC consegue taxa de compressão bem superior que seu antecessor. Uma das
características desse sistema é a propriedade de análise da redundância da informação entre
vários fluxos. Permite também acomodar até 48 fluxos de áudio e até 15 programas distintos.
Pode ser transmitido em 2 ou 5.1 canais [SILVA, 2003].
Na camada de transporte foi adotado o padrão MPEG-2 System. Este padrão adiciona
aos fluxos elementares de áudio principal e vídeo principal informações para suas exibições
sincronizadas. A sincronização é realizada seguindo o paradigma de eixo do tempo (timeline)
pela adição de carimbos de tempo (timestamp) a conjuntos de amostras codificadas de vídeo e
áudio baseado em um relógio compartilhado. A geração de fluxos de dados também são
determinadas pelo padrão [BARBOSA & SOARES, 2008].
22
modular os sinais, diferindo no acréscimo da codificação, de onde se acrescenta o “C” ao
OFDM [RODRIGUES & GOMES, 2004].
23
3. O GINGA E SUA ARQUITETURA
O Ginga define uma API padrão, que todo exibidor acoplado ao sistema deve
obedecer, para reportar seus eventos e serem comandados por ações geradas pelo formatador.
Exibidores de terceiros fabricantes, incluindo aí os browsers HTML, usualmente necessitam
de um módulo adaptador para realizar essas funções e se integrarem ao Ginga [TELEMÍDIA,
2008].
Por ser mais recente, o sistema brasileiro de TV digital teve por obrigação procurar as
alternativas tecnológicas atuais. Entre elas estava à concepção de um middleware no qual a
convivência dos ambientes declarativo e procedural fosse a mais eficiente possível em termos
de custo e desempenho.
24
dos vários objetos de mídia, o controle do plano gráfico, o tratamento de dados obtidos do
carrossel de objetos DSM-CC1, o tratamento do canal de retorno, entre outras.
Ginga-NCL foi desenvolvido pela PUC - Rio visando prover uma infra-estrutura de
apresentação para aplicações declarativas escritas na linguagem NCL (Nested Context
Language). NCL é uma aplicação XML (eXtensible Markup Language) com
facilidades para a especificação de aspectos de interatividade, sincronismo espaço-temporal
entre objetos de mídia, adaptabilidade, suporte a múltiplos dispositivos e suporte à produção
ao vivo de programas interativos não-lineares.
Por ser uma aplicação XML, a linguagem NCL possui uma separação estrita entre
conteúdo e estrutura, NCL não define qualquer mídia por ela mesma. Ao invés, ela é a cola
que mantém a mídia junta com uma apresentação multimídia. Porém, um documento NCL
somente define como os objetos de mídia são estruturados e relacionados, no tempo e no
1
Como a sintonização de um canal específico de TV pode ser realizada em qualquer instante, o
Carrossel DSM-CC envia ciclicamente dados que não tenham relação temporal por meio de carimbos de tempo.
O recebimento desses dados é independente do instante de sintonização.
25
espaço. Como uma linguagem de cola, ela não restringe ou prescreve o conteúdo do tipo de
objeto de mídia [SOARES, 2007].
Objetos de vídeo (MPEG etc.), áudio (AAC etc.), imagem (JPEG, GIF etc.) e texto
(TXT, HTML etc.) são exemplos de objetos de mídia. Entre esses objetos ressaltam-se os
objetos de vídeo e áudio que, no SBTVD, são tratados por exibidores em hardware
[TELEMÍDIA, 2008].
Outro objeto importante no sistema brasileiro é aquele baseado em XHTML. NCL não
substitui XHTML, mas a complementa naquilo que ela é incapaz de cumprir como uma
linguagem declarativa. Diferente do XHTML a linguagem NCL não mistura a definição do
conteúdo de um documento com sua estruturação. Dependendo do browser embutido no
Formatador NCL será determinado qual objeto XHTML terá suporte. De acordo com essa
escolha, teremos compatibilidade com os padrões europeu, americano ou japonês
[TELEMÍDIA, 2008].
Durante a exibição dos conteúdos dos vários objetos de mídia, eventos são gerados.
Eventos podem gerar ações (de sincronismo) em outros objetos de mídia, tais como parar,
iniciar ou pausar suas apresentações. Assim, os eventos devem ser reportados pelos diversos
exibidores ao Formatador NCL que, por sua vez, gerará ações a serem aplicadas em outros
objetos de mídia, fazendo com que as relações de sincronismo entre os objetos de mídia
existentes sejam respeitadas [TELEMÍDIA, 2008].
O ambiente declarativo é, por si só, muito restrito. Aplicações que utilizem uma
linguagem declarativa devem ter seu foco no sincronismo, sendo o foco da linguagem NCL
exatamente esse, e não a interatividade, visto que a interatividade é tratada como uma
decorrência do sincronismo [SOARES, 2007].
26
3.1.1. Lua
Por ser uma linguagem de extensão, Lua não possui a noção de um programa
principal: ela somente funciona embarcada em um programa cliente anfitrião, chamado de
programa hospedeiro ou simplesmente de hospedeiro. Esse programa hospedeiro pode
invocar funções para executar um pedaço de código Lua, pode escrever e ler variáveis Lua e
pode registrar funções C para serem chamadas pelo código Lua [IERUSALIMSCHY, 2007].
Lua funciona como uma máquina virtual (engine) acoplada ao Formatador NCL.
Isso significa que, além de sintaxe e semântica, Lua fornece uma API que permite a troca de
dados com aplicações. É importante também destacar a integração entre Lua e Java, através
da biblioteca LuaJava, que permite o acesso a qualquer classe de Java a partir de Lua, de
forma similar ao que acontece com ECMAScript [ECMA, 2008]. Além disso, o LuaJava
permite que a manipulação do ambiente de Lua a partir de Java, tornando-se, assim, parte da
ponte entre os ambientes declarativo e procedural do middleware Ginga [TELEMÍDIA,
2008].
27
3.1.2. Edição em Tempo Real
Diferente desse cenário, a edição ao vivo requer outros requisitos. Para atender estes
requisitos um sistema de TV digital interativa, e conseqüentemente seu ambiente de autoria,
deve prover meios para se definir uma especificação inicial do documento. Como também,
deve prover meios para modificar essa especificação em tempo de apresentação no ambiente
do cliente telespectador [GUIMARÃES, 2007].
Ginga-J foi desenvolvido pela Universidade Federal da Paraiba para prover uma infra-
estrutura de execução de aplicações baseadas em linguagem Java, chamadas de Xlet, com
facilidades especificamente voltadas para o ambiente de TV digital.
As Xlets não precisam estar previamente armazenadas no STB, pois podem ser
enviadas pelo canal de difusão. Ou seja, o modelo Xlet é baseado na transferência de código
executável pelo canal de difusão para o STB e posterior carga e execução do mesmo, de
forma automática ou manual. Uma Xlet é bastante similar a um Applet na Web ou MIDlet em
celulares e outros dispositivos móveis [FERNANDEZ, 2004].
28
Buscando controlar as Xlets, cada STB possui um Gerente de Aplicações (Application
Manager) instalado. Um gerente de aplicações lida com os estados de cada Xlet, permitindo
iniciar sua execução, destruir, pausar e retomar sua execução. Esses estados são necessários,
pois uma aplicação pode ser pausada momentaneamente se esta for ocultada por um vídeo de
TV; ou ainda pode ser destruída caso o usuário troque de canal. A Xlet precisa ser notificada
quando seu estado muda (por exemplo, quando é pausada) e, assim, pode lidar com seus
recursos (ex. liberar memória).
29
midllawares de TV digital que seguem essas especificações. O GEM é baseado no
middleware MHP e especifica um conjunto de APIs para serem usadas no desenvolvimento
de aplicações para a TV digital, incluindo as APIs provenientes de pacotes da Sun JavaTV,
DAVIC [DAVIC, 1999] e HAVI [HAVi, 2001].
A API Java TV é uma extensão para a plataforma Java para sustentar a produção de
conteúdo interativo de forma procedural para a televisão digital. A principal finalidade da API
Java TV é fornecer um conjunto de métodos, classes e interfaces para facilitar a construção de
aplicativos destinados a serem executados através de plataformas de recepção de televisão
digital independentes das tecnologias utilizadas na rede de transmissão [ABNT 00:001.85-
006/4].
30
Utilizando-se de sua arquitetura a API JavaTV é capaz de executar funcionalidades,
como:
A API JavaTV tem várias bibliotecas, que são responsáveis por prover a estrutura
básica do sistema. As bibliotecas estão dispostas da seguinte forma:
31
Java TV tem sido amplamente adotado por organizações de padronização, tornando-o
um forte candidato a padrão mundial para conteúdo de televisão digital interativa. Temos
como exemplo, as diversas implementações de middleware que adotaram o modelo Java TV,
com ligeiras diferenças entre si.
O sistema DAVIC tem suas próprias API, e portanto ele também pode ser considerado
como um middleware de alto nível (apesar de ser comum para ele operar em conjunto com
um middleware de nível mais baixo). A seguir são listados os pacotes que são parte da API
DAVIC incluídos no Ginga-J [ABNT 00:001.85-006/4]:
• org.davic.media
• org.davic.resources
• org.davic.mpeg
• org.davic.mpeg.sections
• org.davic.net
• org.davic.net.dvb
• org.davic.net.tuning
32
O principal objetivo de uma interface de usuário é oferecer um ambiente operacional
fácil de usar. A arquitetura HAVi permite que os usuários controlem dispositivos de forma
familiar, através de um controle remoto ou de uma tela frontal. A seguir são listados os
pacotes que são parte do HAVi API incluídos no Ginga-J API [ABNT 00:001.85-006/4]:
• org.havi.ui
• org.havi.ui.event
• org.dvb.application
• org.dvb.dsmcc
• org.dvb.event
• org.dvb.io.ixc
• org.dvb.io.persistent
• org.dvb.lang
• org.dvb.media
• org.dvb.net
• org.dvb.net.tuning
• org.dvb.net.rc
• org.dvb.test
• org.dvb.ui
33
3.3. A PONTE ENTRE O GINGA-NCL E O GINGA-J
34
Outra inovação do middleware brasileiro é a ponte entre o ambiente declarativo e o
procedural, no qual uma aplicação pode alterar e/ou executar uma aplicação de outro
ambiente.
35
4. GUIA DE DESENVOLVIMENTO DE UM APLICATIVO PARA TV DIGITAL
Ambiente
Ginga-NCL
Ginga-J
Níveis de
Emissora Interatividade
Desenvolvedor
A TV Digital é mais do que uma imagem e um som de alta definição. Com ela é
possível desenvolver, para a televisão, aplicativos com capacidade computacional, como os de
desktops, que permitem armazenar e processar informações, e desde que exista um canal de
retorno possibilitando a construção de aplicações interativas.
Essas aplicações podem ser desenvolvidas tanto pelas emissoras de televisão quanto
pelos usuários. Caso seja desenvolvida por uma emissora, a aplicação será enviada ao set top
box através do canal de transmissão. No caso de ser desenvolvida por um usuário esta terá que
ser enviada ao set top box através de uma entrada externa (porta USB, porta de rede, cartão de
memória, etc).
36
Definido o nível de interatividade e o desenvolvedor, deve-se então definir o ambiente
de execução. Como visto no capítulo anterior, o Ginga oferece dois ambientes de execução: o
ambiente para aplicações declarativas Ginga-NCL e o ambiente para aplicações não-
declarativo Ginga-J.
37
Figura 7 - Diagrama com as opções de desenvolvimento
Nos tópicos seguintes deste capítulo é descrito os conceitos dos objetos NCL e do
funcionamento dos Xlets utilizadas.
38
Figura 8 – Display exibindo várias Xlets
Todo objeto deve ter o seu comportamento determinado. Para isto, a sua declaração,
deve definir o que se quer tocar, como, quando e onde.
• Onde tocar: com o conteúdo definido, podemos associar uma mídia a uma região.
Esta associação é feita através de um descritor. Para isso, devemos indicar as posições
39
e as dimensões dos nós num local específico através de elementos denominados
regiões.
• Como tocar: os descritores também são utilizados para definir a forma como a mídia
deverá ser apresentada. Por exemplo, podemos definir para um áudio o seu volume;
para uma imagem o seu grau de transparência.
A idéia básica de uma Xlet é funcionar como uma máquina de estados em cima da
máquina virtual que a está executando. As Xlets implementam a interface Javax.tv.xlet.Xlet
que provê um ciclo de vida para a aplicação através da implementação de seus métodos. Cada
método da interface provê uma transição a um estado da aplicação [MONTEZ, 2005].
40
Figura 9 - Estados de um Xlet
Segue abaixo uma breve descrição dos métodos da interface Javax.tv.xlet.Xlet que
devem ser implementados para a construção de um Xlet [SUN, 2000].
Toda Xlet deve possuir um contexto que de uma maneira geral serve para isolar a
aplicação do resto da máquina virtual. Um objeto XletContext é passado a uma Xlet quando
ele é inicializado. É através desta interface que o Gerenciador de Aplicações controla o estado
de um Xlet. Entre outras, o contexto permite a Xlet descobrir informações a respeito do
ambiente de execução. [MONTEZ et al, 2005]
41
A interface XletContext define os seguintes métodos [SUN, 2000]:
42
Este modelo é o que melhor cumpre com as exigências do ambiente de
desenvolvimento de aplicações para TV interativa. São definidos três camadas conceituais de
imagem: a camada de imagem de fundo de tela (background), a camada de vídeo e a camada
gráfica que exibe ao usuário a interface da aplicação. As camadas são sobrepostas para
produzir a imagem vista pelo usuário final.
43
5. ESTUDO DE CASO
Para minimizar as duvidas e necessidades que temos frente à escolha entre alternativas
surgem então os sistemas de recomendação que tem o objetivo de recomendar itens a um
usuário através de uma filtragem de informações relevantes baseadas no seu perfil de interesse
[ELISEO & SILVIO].
44
que realmente necessitam delas. São aplicadas duas técnicas de filtragem nos sistemas de
recomendação: filtragem baseada em conteúdo e filtragem colaborativa [ELISEO & SILVIO].
45
Ambiente
Ginga-NCL
Ginga-J
Níveis de
Emissora Interatividade
Desenvolvedor
46
Segundo a comunidade de IA Sistemas de Recomendação são sistemas de informação
que coletam indicadores da preferência dos usuários e utilizam técnicas de Filtragem de
Informação (FI) para fornecer uma visão personalizada da informação. Na aplicação
AutoCanal foi apenas considerada informações do próprio usuario para realizar a
recomendação.
Esta aplicação possibilita ao usuário assistir três canais diferentes (de forma simulada),
os quais podem ser trocados pelo controle remoto através dos botões 1, 2 e 3. A medida que o
usuário vai assistindo os canais a aplicação guarda informações (canal e hora) para
posteriormente sugerir uma programação ao usuário de acordo com o seu histórico. Nesta
aplicação é simulado tanto a transmissão dos canais como o tempo.
47
6. CONCLUSÃO
Além do levantamento realizado sobre o SBTVD e seu middleware Ginga foi criado
um guia para o desenvolvimento de aplicativos para TV digital. Através da leitura deste guia
um desenvolvedor terá conhecimento de quais são os ambientes de desenvolvimento
disponíveis e quais são os passos que devem ser seguidos a fim de construir um aplicativo
suportado pelo middleware brasileiro.
Por fim, este trabalho vem servir de referência para que outros alunos e profissionais
interessados neste tema possam compreender melhor o funcionamento do SBTVD e assim
nortear no desenvolvimento de aplicativos para TV digital.
48
REFERÊNCIAS BIBLIOGRÁFICAS
[BARBOSA & SOARES, 2008] BARBOSA, Simone; SOARES, Luiz. TV Digital no Brasil
se faz com Ginga: Fundamentos, Padrões, Autoria Declarativa e Usabilidade. Rio de Janeiro,
RJ: Editora PUC-Rio, 2008.
[CRUZ, 2008] CRUZ, Vitor Medina; MORENO, Marcio Ferreira; SOARES, Luis Fernando
Gomes. TV Digital para Dispositivos Portáteis – Middlewares. PUC-RIO. Janeiro 2008.
[DASE, 2008] Standard A/100 - DTV Application Software Environment – Level 1 (DASE-
1). Disponível em www.atsc.org e acessado em junho de 2008.
49
[FERNANDEZ, 2004] FERNANDEZ, J.; LEMOS, Guido.; SILVEIRA, G. Introdução à
Televisão Digital Interativa: Arquitetura, Protocolos, Padrões e Práticas. In JAI-SBC.
Salvador, 2004.
[HAVi, 2001]. HAVi v1.1 - Home Audio Video Interoperability Version 1.1. Disponível em
www.havi.org e acessado em junho de 2008.
[LEMOS, 2007] LEMOS, Guido; LEITE, Luiz; BATISTA, Carlos. Ginga-J: The
Procedural Middleware for the Brazilian Digital TV System. JCBS. no. 1; Vol. 13; Mar.
2007
50
[LOPES, 2007] LOPES, Denise. Sistema Brasileiro de TV Digital: Caminhos percorridos e
implantação. V Congresso Nacional de História da Mídia. São Paulo, 2007.
[MENDES, 2007] MENDES, Luciano Leonel. Artigo: SBTVD – Uma Visão sobre a TV
Digital No Brasil. T&C Amazônia Ano V, Numero 12, Outubro de 2007.
[RICHARDSON, 2003] Richardson, Iain. H.264 and MPEG-4 Video Compression Video
Coding for Next-generation Multimedia. John Wiley & Sons Ltd, The Atrium, Southern
Gate, Chichester, 2003.
51
[SOUZA, 2004] SOUZA, Vinicius Barros. Set Top Box para TV Interativa. Monografia.
Universidade Federal Fluminense. Niteroi, 2004.
[SPARANO, 2000] Sparano, D. What Exactly is 8-VSB Anyway?. The Guide to Digital
Television, 3ª ed. Silbergleid & Pescatre org, Miller Freeman Inc, March 2000.
[SUN, 2000] Java TV 1.0 - Java TV API Technical Overview: The Java TV API White
Paper. Version 1.0, Sun Microsystems. November 2000.
52
APÊNDICE A – TUTORIAL DE DESENVOLVIMENTO DE UM APLICATIVO EM
JAVATV
1. FERRAMENTAS UTILIZADAS
Os exemplos dados para a elaboração deste guia serão baseados na IDE Eclipse.
1.2. Xletview
O XletView, ver interface na Figura 1, é uma ferramenta que emula Xlets para TV
Digital em um computador. Possui código aberto (Open Source), recursos multimídias
53
implementados para utilização dos componentes HAVi, é baseado no padrão MHP e fornece
uma maneira fácil e rápida de testar as aplicações.
Como é programado totalmente em Java, pode ser executado tanto em uma plataforma
Linux ou Windows, bastando para isso utilizar o Java 2 Standard Development Kit para
compilar Xlets e executar o XleTView. A versão utilizada deste emulador foi a 0.3.6 em
conjunto com o JMF 2.1.1. O Xletview possui muita limitações, não dá suporte a todas as
funcionalidades oferecidas pela API JavaTV, como também é bastante limitada para
reproduzir a maioria das codificações de vídeo.
54
2. CONFIGURANDO O AMBIENTE DE DESENVOLVIMENTO
Para realizar esta operação, no Eclipse, após ter um projeto criado, vá a propriedades,
escolha a opção “Java Build Path”, na aba “Libraries” clique em “Add External JARs” e
adicione as bibliotecas “javatv.jar” e “xletview.jar”.
A partir deste ponto podemos dar início a implementação de uma Xlet. No Exemplo
01 temos um código que serve de estrutura base para a implementação de um simples Xlet.
/**
* Esta é uma implementação simples de um Xlet.
* Serve de esqueleto para a construção de aplicações
* mais elaboradas. Pois toda Xlet deve ter esta estrutura.
*/
/**
* Este Xlet implementa a interface Javax.tv.xlet.Xlet
* e todos os métodos são herdados desta interface.
*/
public class SimplesXlet implements Xlet {
55
private XletContext context;
public SimplesXlet() {
/**
* Toda Xletdeve ter um construtor padrão onde nada
* deve ser feito. Qualquer inicialização deve ser
* feita no método initXlet() ou em startXlet(). Desta
* forma o middleware pode controlar a inicialização
* de uma forma mais previsível. *
*/
}
56
3.1. Inserindo Texto
a) Importar bibliotecas
import javax.tv.xlet.Xlet;
import javax.tv.xlet.XletContext;
import javax.tv.xlet.XletStateChangeException;
import org.havi.ui.HScene;
import org.havi.ui.HState;
import org.havi.ui.HStaticText;
import java.awt.Color;
import java.awt.Font;
scene.add(texto);
a) Importar bibliotecas
import javax.tv.xlet.Xlet;
import javax.tv.xlet.XletContext;
import javax.tv.xlet.XletStateChangeException;
import org.havi.ui.HDefaultTextLayoutManager;
import org.havi.ui.HScene;
import org.havi.ui.HTextButton;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.KeyListener;
57
b) Implementar a classe KeyListener
scene.add(botao1);
scene.add(botao2);
a) Importar bibliotecas
import javax.swing.ImageIcon;
import javax.tv.xlet.XletContext;
import javax.tv.xlet.XletStateChangeException;
import org.havi.ui.HContainer;
import org.havi.ui.HIcon;
58
import java.awt.Image;
container.add(icone);
a) Importar bibliotecas
import javax.tv.xlet.XletContext;
import javax.tv.xlet.XletStateChangeException;
import org.havi.ui.HContainer;
import org.havi.ui.HSound;
SOM_URL = "file://c://sons//som.mp3";
try{
som.load(SOM_URL);
}
catch (Exception e) {
e.printStackTrace();
}
som.play();
59
Para inserir vídeo você deve:
a) Importar bibliotecas
import javax.tv.xlet.XletContext;
import javax.tv.xlet.XletStateChangeException;
import org.havi.ui.HContainer;
import org.havi.ui.HScene;
import javax.media.ControllerListener;
import javax.media.Manager;
import javax.media.MediaException;
import javax.media.MediaLocator;
import javax.media.Player;
import java.awt.Component;
import java.io.IOException;
VIDEO_URL = "file://C://Videos//video.avi";
try {
mediaLocator = new MediaLocator(VIDEO_URL);
player = Manager.createRealizedPlayer(mediaLocator);
player.addControllerListener((ControllerListener) this);
}
catch (IOException e) {
e.printStackTrace();
}
catch (MediaException e) {
e.printStackTrace();
}
scene.add(contVideo);
scene.repaint();
60
a) Importar bibliotecas
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.tv.xlet.Xlet;
4. EXECUTANDO UM XLET
iii. Informe o nome da sua aplicação, o caminho onde se encontra o arquivo “.class” e
o arquivo “.class” propriamente dito. Salve e feche a janela.
Para executar a Xlet, basta abrir o menu "Applications" e clique no nome que foi dado.
61
APÊNDICE B - CÓDIGO DE IMPLEMENTAÇÃO DA APLICAÇÃO AUTOCANAL
/**
* @author João Paulo Lacerda - jplacerda@gmail.com
* Antônio Carlos Albuquerque - antonioc.albuquerque@gmail.com
*
* A Xlet AutoCanalXlet possibilita ao usuário assistir três canais
* (de modo simulado) diferentes que podem ser trocados no controle
* remoto nos botões 1, 2 e 3.
* A medida que o usuário vai assistindo os canais a aplicação vai
* guardando informações para posteriormente sugerir a programação
* ao usuário de acordo com o seu histórico.
*/
//Importando a AWT
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
//Importando a HAVi
import org.havi.ui.HContainer;
import org.havi.ui.HDefaultTextLayoutManager;
import org.havi.ui.HScene;
import org.havi.ui.HSceneFactory;
import org.havi.ui.HScreen;
import org.havi.ui.HState;
import org.havi.ui.HStaticText;
import org.havi.ui.HTextButton;
import org.havi.ui.HTextLayoutManager;
import org.havi.ui.event.HRcEvent;
/**
* Esta Xlet implementa a interface Javax.tv.xlet.Xlet e
* a java.awt.event.KeyListener.
*/
public class AutoCanalXlet implements Xlet, KeyListener {
62
private HStaticText nr_canal;
private HStaticText hora_text;
private HStaticText mudarCanal;
private VideoPlayer canal_01 = new VideoPlayer(1);
private VideoPlayer canal_02 = new VideoPlayer(2);
private VideoPlayer canal_03 = new VideoPlayer(3);
private Component videoComp_01, videoComp_02, videoComp_03;
private AutoProgramacao autoProgramacao = new AutoProgramacao();
private int canal = -1;
private boolean cancelar = true;
private boolean continuar = true;
/**
* Toda Xletdeve ter um construtor padrão onde nada deve ser feito.
* Qualquer inicialização deve ser feita no método initXlet() ou
* em startXlet(). Desta forma o middleware pode controlar a
* inicialização de uma forma mais previsível.
*/
public AutoCanalXlet() {}
/**
* Inicializa o Xlet. É neste método que o contexto da Xletdeve
* ser passado para futuras referências. É o lugar onde as
* inicializações devem ser feitas a não ser que tenha um custo
* computacional muito alto.
* O controle de exeção XletStateChangeException deve ser
* referenciado para o caso de ocorre um erro na inicialização.
*/
public void initXlet(XletContext context) throws
XletStateChangeException {
System.out.println("initXlet");
this.context = context;
scene = HSceneFactory.getInstance().getFullScreenScene(
HScreen.getDefaultHScreen().getDefaultHGraphicsDevice());
if (scene == null)
throw new XletStateChangeException("Impossivel criar
HScene");
}
/**
* Ativa o Xlet. Neste ponto a Xlet pode ser mostrado na tela e
* começar a interação com o usuário ou realizar outra tarefa.
* Este tipo de tarefa não deve ser feita no initXlet().
*
* Como em iniXlet o controle de exeção XletStateChangeException deve
* ser referenciado para o caso de ocorre um erro ao ativar o Xlet.
*/
public void startXlet() throws XletStateChangeException {
System.out.println("startXlet");
videoComp_01 = canal_01.getPlayer().getVisualComponent();
videoComp_02 = canal_02.getPlayer().getVisualComponent();
videoComp_03 = canal_03.getPlayer().getVisualComponent();
videoComp_01.setBounds(0,0,720,500);
videoComp_02.setBounds(0,0,720,500);
videoComp_03.setBounds(0,0,720,500);
63
nr_canal.setBounds(20,510,40,50);
nr_canal.setFont(new Font("Tiresias",Font.BOLD,60));
nr_canal.setForeground(Color.YELLOW);
nr_canal.setBackground(new Color(200,200,200,100));
container.setVisible(true);
container.add(nr_canal);
container.add(hora_text);
container.add(mudarCanal);
container.setBounds(scene.getBounds());
scene.add(container);
scene.addKeyListener(this);
scene.setVisible(true);
scene.requestFocus();
iniciarControleCustomizado();
}
/**
* Pausa o Xlet. Aqui a Xletdeve liberar recursos para que não
* sejam usados de forma desnecessária e deve ser removido da tela.
*/
public void pauseXlet() {
System.out.println("pauseXlet");
}
/**
* Destroi o Xlet. O parâmetro booleano diz ao método se o Xlet
* deve obedecer esta requisição. Se o valor for verdadeiro o Xlet
* deve ser terminado. Caso contrário, a Xletpode informar que não
* foi destruido lançando XletStateChangeException
*/
public void destroyXlet(boolean arg0) throws XletStateChangeException
{
System.out.println("destroyXlet");
if (scene != null) {
scene.setVisible(false);
scene.removeAll();
scene.dispose();
scene = null;
}
canal_01.close();
canal_02.close();
canal_03.close();
continuar = false;
context.notifyDestroyed();
}
64
/**
* No método iniciarControleCustomizado() é implementado um loop
* infinito que contem o método sleep, com uma pausa de 1 segundo
* (simula 1 hora), com o objetivo de emular o tempo.
* A cada loop é registrado o canal que o usuário está assistindo
* através da classe AutoProgramacao, como também é verificado se
* o usuário está assistinto o canal favorito da hora seguinte.
* Caso o canal atual seja diferente do canal favorito, será exibida
* uma mensagem informando que breve haverá uma mudança automática
* de canal e que caso deseje cancelar esta mudança a tecla vermelha
* deve ser pressionada.
*/
public void iniciarControleCustomizado()
{
String hora_minuto = null;
int canal_preferido = -1;
while (continuar) {
for (int hora = 0; hora < 24; hora++ ) {
if ( canal > 0 ) {
autoProgramacao.pontuarCanal(canal, hora);
canal_preferido =
autoProgramacao.getCanal(canal, hora+1);
if ( canal != canal_preferido ) {
mudarCanal.setVisible(true);
System.out.println("canal: " + canal + "
DIFERENTE DE canal_preferido: " + canal_preferido);
mudarCanal.setTextContent("Mudança
prevista para o Canal: " + canal_preferido + " às " +
Integer.toString(hora) + ":00 \n Aperte o botão vermelho para cancelar." ,
HState.ALL_STATES);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mudarCanal.setVisible(false);
if ( cancelar )
setCanal(canal_preferido);
cancelar = true;
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//Atualiza a hora
hora_text.setTextContent(Integer.toString(hora) +
":00", HState.ALL_STATES);
}
}
}
/**
* Este método muda o canal (o vídeo que está sendo exibido) de
* acordo com o valor passado no parâmetro.
* @param canal
*/
public void setCanal(int canal) {
this.canal = canal;
65
System.out.println("setCanal: " + canal);
//Atualiza o canal
nr_canal.setTextContent(Integer.toString(canal),
HState.ALL_STATES);
canal_01.pause();
canal_02.pause();
canal_03.pause();
container.remove(videoComp_01);
container.remove(videoComp_02);
container.remove(videoComp_03);
if (canal == 1) {
container.add(videoComp_01);
canal_01.start();
}
if (canal == 2) {
container.add(videoComp_02);
canal_02.start();
}
if (canal == 3) {
container.add(videoComp_03);
canal_03.start();
}
}
/**
* Este método responde aos eventos do controle remoto. Caso o botão
* 1, 2 ou 3 seja pressionado será chamado o método setCanal().
*/
public void keyPressed(KeyEvent e) {
System.out.println("keyPressed: " + e.getKeyChar());
if(e.getKeyChar() == HRcEvent.VK_ESCAPE){
try {
destroyXlet(true);
} catch (XletStateChangeException e1) {
e1.printStackTrace();
}
}
}
A CLASSE AUTOPROGRAMACAO
66
/**
* @author João Paulo Lacerda - jplacerda@gmail.com
* Antônio Carlos Albuquerque -
antonioc.albuquerque@gmail.com
*
* Esta classe implementa a inteligência artificial da aplicação.
* Nela é criada uma matriz de 3 por 24. O 3 representa o número de canais
* e o 24 o intervalo de tempo, neste caso é o número de horas .
* Todos os valores da matriz iniciam com valor 0 e podem ser incrementados
* de acordo com o canal que o usuário assiste em determinada hora. Criando
* assim um sistema de pontuação que possibilita a aplicação saber qual
* o canal favorito do usuário em uma determinada hora.
*/
/**
* Retorna o canal preferido, o canal de maior pontuação, em uma
* determinada hora.
* @param canal - é o canal que está sendo assistido
* @param hora - é a hora que se deseja obter o canal favorito.
*/
public int getCanal(int canal, int hora)
{
if ( hora == 24 ) hora = 0;
67
A CLASSE VIDEOPLAYER
/**
* Classe VideoPlayer
* Esta classe instancia o player para
* exibir os vídeos que simulam os canais.
*/
import java.awt.Component;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.IOException;
import javax.media.*;
import javax.media.protocol.*;
import javax.tv.xlet.*;
import org.havi.ui.*;
import org.havi.ui.event.HRcEvent;
if ( canal == 1)
VIDEO_URL = "file://D://Videos//New_Drawing.avi";
else if ( canal == 2)
VIDEO_URL = "file://D://Videos//New_Drawing.avi";
else if ( canal == 3)
VIDEO_URL = "file://D://Videos//Sample.mov";
else
System.out.println("Nenhum canal foi criado");
try {
mediaLocator = new MediaLocator(VIDEO_URL);
player = Manager.createRealizedPlayer(mediaLocator);
player.addControllerListener(this);
}
catch (IOException e) {
e.printStackTrace();
}
catch (MediaException e) {
e.printStackTrace();
}
}
68
//Verifica se o player está instanciado, caso esteja a exibição
//do vídeo será iniciada novamente quando chegar no seu fim
public void controllerUpdate(ControllerEvent ctEvent) {
if(player == null){
return;
}
else if (ctEvent instanceof EndOfMediaEvent) {
player.setMediaTime(new Time(0));
player.start();
}
}
//Inicia o vídeo
public void start() {
System.out.println("start");
if(player != null)
player.start();
}
//Pausa o vídeo
public void pause() {
System.out.println("pause");
if(player != null)
player.stop();
}
69