Desenvolvendo com Media Center Markup Language (MCML)

Conteúdo

Nesta página

Introdução
Conceitos básicos de MCML
Definindo Interfaces com MCML
Trabalhando com View Items
Criando Layouts em MCML
Gerenciando dispositivos de entrada
Trabalhando com Animações
Distribuindo Aplicações Media Center através da Web
Conclusão
Para mais informações
Sobre o Autor

Objetivos: Este artigo tem o objetivo de apresentar a linguagem Media Center Markup Language (MCML) e sua utilização para o desenvolvimento de aplicações com visual rico no Windows Media Center. Integrada com código gerenciado .NET, a MCML permite a criação de sistemas com a mesma experiência televisiva do Media Center.

Introdução

Alinhada às tendências recentes de convergência digital, que transportaram os computadores pessoais para as salas de estar para uso como centro de entretenimento, a Microsoft lançou em 2002 uma versão especial do Windows XP, denominada Windows XP Media Center Edition. O grande destaque dessa versão especial do Windows foi um recurso denominado Windows Media Center (WMC), especialmente modelado para que o usuário pudesse acessar suas bibliotecas de fotos, músicas e vídeos usando apenas um controle remoto.

Contemplando também os desenvolvedores, a Microsoft tornou possível o desenvolvimento de aplicações que estendiam as funcionalidades padrão do Media Center, através da criação de addins em .NET ou HTML. No entanto, não havia uma maneira simples e padronizada de desenvolver addins que proporcionassem ao usuário uma experiência consistente com a já proporcionada pelo próprio Media Center.

Os usuários das versões Home Premium e Ultimate do Windows Vista receberam a nova versão do Windows Media Center junto com o sistema operacional. Além da maior integração com a Web e da adição de diversos recursos novos para gerenciamento de arquivos multimídia, essa versão passou por um total remodelamento da interface com o usuário (que está muito mais bonita e intuitiva do que a versão anterior), conforme ilustrado na Figura 1.

Figura 1. Interface principal do Windows Media Center

Para os desenvolvedores, o Media Center do Windows Vista introduziu uma nova maneira de desenvolver aplicações, acessível através do Windows Media Center Software Development Kit (SDK), disponibilizado gratuitamente. Com essa nova versão do WMC, é possível utilizar a camada de apresentação do Media Center para criar aplicações que façam uso de sua tecnologia de renderização, de modo a proporcionar uma experiência ao usuário com a mesma riqueza e qualidade do próprio Media Center. Isto é possível através da utilização da Windows Media Center Markup Language (MCML), linguagem de marcação baseada em XML para a especificação de interfaces no Media Center.

A linguagem MCML possui diversas características que simplificam bastante a criação de interfaces idênticas às apresentadas pelo Media Center. Ela suporta layouts dinâmicos, possui suporte integrado a animações, imagens e texto enriquecido, além de suportar binding condicional entre componentes e dados. Além disso, possui suporte nativo à navegação com teclado, mouse e controle remoto de maneira transparente para o desenvolvedor. Por fim, outra característica fundamental da MCML é a possibilidade de acessar assemblies gerenciados do .NET a partir da linguagem. Com isso, é possível contar com as vantagens de um modelo de programação em que a interface está separada da lógica da aplicação, de forma semelhante a aplicações desenvolvidas em ASP.NET.

Existem três tipos de aplicações que utilizam a camada de apresentação do Windows Media Center: locais, de background e Web. As aplicações locais são compostas de um ou mais assemblies gerenciados, além de arquivos MCML e arquivos de recursos (imagens, sons e vídeos) relacionados. Da mesma forma que qualquer programa instalado localmente, elas possuem acesso irrestrito a todos os recursos do computador na qual estão instaladas.

As aplicações de background são um tipo especial de aplicações locais que não possuem interface gráfica, mas oferecem serviços que estendem as funcionalidades padrão da interface do Media Center para serem usadas por outras aplicações. Exemplos de aplicações de background incluem o suporte a tipos alternativos de controles remotos e a criação de scripts para automatizar tarefas.

Já as aplicações Web para Media Center usam MCML acessado remotamente via protocolo HTTP através de servidores na internet. Não requerem, dessa forma, a instalação de qualquer arquivo no computador local. O Windows Media Center oferece um ambiente seguro no qual as aplicações remotas possuem acesso completo à API do Media Center e a um subconjunto significativo do .NET Framework, suficiente para suportar aplicações típicas desenvolvidas nesse cenário.

No decorrer deste artigo, será apresentada uma visão geral de desenvolvimento com MCML, focando a criação de aplicações locais e Web para o Windows Media Center.

Conceitos básicos de MCML

Como dito anteriormente, a camada de apresentação do Windows Media Center separa a parte visual da lógica das aplicações, através de uma abordagem modelo/visualização (do inglês model/view). Nessa abordagem, a visualização (view) contém todos os elementos de interface com o usuário. Já o modelo (model) é responsável pela lógica da aplicação, tendo a missão de atualizar a informação apresentada pela visualização e de determinar como é feita a navegação entre as diversas telas do sistema. O modelo é desenvolvido com uma linguagem gerenciada (como C# ou VB.NET) sobre o .NET Framework.

A separação modelo/visualização é interessante, pois permite que designers e desenvolvedores trabalhem em paralelo na criação de aplicações Media Center. No entanto, é essencial que a visualização esteja conectada a um modelo para que a interação do usuário com a aplicação possa ocorrer de forma completa.

Mas de que forma a MCML consegue ter acesso ao código gerenciado? A MCML mapeia objetos da CLR (Common Language Runtime) do .NET em elementos (elements) e suas propriedades em atributos (attributes) do XML. A estrutura da MCML define elementos aninhados que contêm atributos que, por sua vez, podem conter outros elementos com seus próprios atributos.

O código a seguir ilustra a estrutura típica de um arquivo MCML. Note que o principal elemento do arquivo, localizado em um nível imediatamente interno à tag raiz <Mcml>, é o elemento UI (de User Interface), responsável por englobar todos os elementos visuais da página. Porém, é possível declarar mais de um elemento deste tipo por arquivo MCML, quando se deseja definir tipos visuais mais complexos (normalmente compostos de vários elementos básicos) em uma seção separada do arquivo. Estes tipos podem, então, ser importados em outra UI.

<Mcml xmlns="http://schemas.microsoft.com/2006/mcml">
  <UI Name="Exemplo1">
    
    <!-- "Content" é um atributo do elemento "UI". -->
    <Content>
      
      <!-- "ColorFill" é um elemento e um atributo de "Content". -->
      <ColorFill Content="Firebrick">
        
        <!-- "Children" é um atributo de "ColorFill". -->
        <Children>
          
          <!-- "Text" é um elemento e um atributo de "Children". -->
          <Text Content="Content é um atributo do elemento "Text", que por sua vez é um atributo de "Children" 
                Font ="Arial,12" Color="White" />
          
        </Children>
      </ColorFill>
    </Content>
  </UI>
</Mcml>

	

A MCML permite que atributos sejam declarados tanto de forma inline (dentro da mesma tag em que o elemento é definido), como na forma expandida, em que os atributos são declarados em suas próprias tags. No código abaixo, é possível ver um exemplo de cada tipo de declaração de atributos:

          <!-- Método "inline" -->
          <Text Content="Método inline" Font="Verdana,14" />


          <!-- Método "expandido" -->
          <Text Content="Método expandido" >
            <Font>
              <Font Font="Verdana,14"/>
            </Font>
          </Text>

	

Neste ponto, vale salientar que existem algumas palavras reservadas em MCML, que por esta razão não podem ser usadas para dar nome a qualquer elemento (o que é feito através da propriedade Name do mesmo). Definir um nome para os elementos é útil quando se quer referenciá-lo em outro ponto do código MCML. As palavras reservadas estão listadas a seguir:

• $Required

• Accessible

• Focus

• Input

• Me

• Parent

• RepeatedItem

• RepeatedItemIndex

• RequestMethod

Em linhas gerais, um código MCML válido está sujeito às mesmas regras que um código XML bem formatado. Isso significa, por exemplo, que a MCML é case sensitive (ou seja, ‘UmElemento’ é diferente de ‘Umelemento’, que é diferente de ‘umelemento’), da mesma forma que o XML. Entretanto, existem regras específicas da sintaxe do MCML que devem ser checadas antes de iniciar o desenvolvimento. Para informações sobre essas regras, consulte a documentação do SDK do Media Center.

É importante ter em mente que os tipos definidos nas tags MCML não são globais. Ao contrário, o escopo das mesmas é local para cada elemento UI do MCML. Para acessar um tipo MCML definido em outro elemento UI (e para resolver conflitos de nomes), é necessário usar o conceito de namespace, similar ao que acontece no XML. Além disso, todos os tipos, tanto da CLR quanto os definidos em MCML, precisam possuir necessariamente um prefixo (por exemplo, <cor:String…> e <ctl:Button…>). As exceções são os tipos definidos nos namespaces padrão, como será mostrado a seguir.

Os arquivos MCML contêm uma referência para o namespace do Windows Media Center, feito no atributo xmlns da tag raiz <Mcml>, através da URI (Universal Resource Identifier) "http://schemas.microsoft.com/2006/mcml". Essa URI, na verdade, é um alias para o assembly Microsoft.MediaCenter.UI da API. A primeira linha do primeiro código mostrado ilustra esse mapeamento. Note que é possível alterar o namespace padrão ou definir outros namespaces como padrão por meio da definição de várias declarações xmlns. Os tipos definidos dentro destes namespaces podem ser referenciados sem a necessidade de adicionar prefixos.

Dentro do arquivo MCML, é possível referenciar recursos (imagens, sons, outros arquivos MCML, sites na Web, etc.) usando uma URI. MCML suporta os seguintes tipos de recursos:

• file: usado para acessar arquivos em disco. Exemplo: file://c:\video.mpg;

• http/https: usado para acessar recursos na Web. Exemplo: http://www.domino.com/arquivo.mcml;

• res: usado para acessar recursos armazenados em DLLs nativas Win32. Exemplo: res://NomeDaDll!MinhaMusica.wav;

• resx: usado para acessar recursos armazenados em DLLs gerenciadas do .NET. Exemplo: resx://NomeDoAssemblyl!MinhaImagem.jpg.

De forma semelhante, é possível referenciar assemblies a partir de um arquivo MCML, usando o prefixo ‘assembly://’. O código a seguir mostra o mapeamento entre o prefixo ‘cor’ e o namespace System. Vale ressaltar que os assemblies precisam ter um strong name e necessitam estar na GAC (Global Assembly Cache)

xmlns:cor="assembly://MSCorLib/System" 
	

Um dos principais assemblies de interesse do desenvolvedor de aplicações para Media Center é o Microsoft.MediaCenter.Hosting. Todos os serviços do Windows Media Center, como os responsáveis pela reprodução de áudio e vídeo, são iniciados a partir da classe AddInHost, desse namespace. Dessa forma, é necessário adicionar uma referência a esse assembly usando declarações xmlns, como mostrado na primeira linha do código a seguir. Em seguida, basta instanciar os objetos desse namespace na seção Locals do elemento UI e utilizá-los normalmente dentro dos outros elementos da UI. A seção locals também é mostrada a seguir:

<Mcml xmlns="http://schemas.microsoft.com/2006/mcml">

  <!-- Note o prefixo 'addin', que será usado para referenciar este namespace posteriormente -->
  xmlns:addin="assembly://Microsoft.MediaCenter/Microsoft.MediaCenter.Hosting"
  
  <UI Name="Exemplo4">

    ...
    
    <Locals>
      <!-- Aqui, o prefixo 'addin' é usado como alias para o namespace definido acima -->
      <addin:AddInHost Name="AddInHost"/>
    </Locals>

    ...

  </UI>
</Mcml>

	

Para ter acesso às propriedades e métodos dos assemblies referenciados, é interessante conhecer o conceito de Object Paths. Eles representam a principal forma de binding de dados em MCML, e através da sua utilização é possível navegar em qualquer objeto definido na CLR usando o seguinte formato: [NomeDoObjeto.MembroA.MembroB]. Note que NomeDoObjeto se refere ao nome de um elemento definido dentro do escopo da UI atual. Porém, é preciso ter em mente as seguintes restrições:

• Não é possível usar Object Paths na seção Properties;

• Em uma seção Locals, Object Paths têm acesso a objetos na seção Properties;

• Em uma Content, Object Paths têm acesso a objetos nas seções Properties e Locals;

• Em uma seção Rules, Object Paths têm acesso a objetos nas seções Properties, Locals e Content.

Mais adiante neste artigo será explicado o papel de cada uma dessas seções na definição da UI.

O código a seguir mostra como chamar uma propriedade estática da estrutura System.DateTime. Para começar, declare o tipo na seção Locals (lembre-se, é necessária uma referência para o namespace System, como mostrado anteriormente, antes de usar DateTime). Em seguida, através do uso de object paths, você pode acessar as propriedades de DateTime na seção Content do elemento UI:

<Mcml
  xmlns="http://schemas.microsoft.com/2006/mcml"
  xmlns:cor="assembly://MSCorLib/System" >
  <UI Name="Statics">
    <Locals>
      <cor:DateTime Name="Display"/>
    </Locals>
    <Content>
      <Text Content="[Display.Now.ToString]" Color="White" />
    </Content>
  </UI>
</Mcml>
	

Object Paths suportam operações de casting de tipos para declarar que o membro atual é de um tipo diferente. Use “!” para fazer um cast de tipos, como mostrado no código a seguir. Nesse exemplo, ‘Item’ é uma propriedade do tipo Object e ‘cor’ é um prefixo de namespace, como mostrado nos exemplos anteriores.

Data.Item!cor:String 
	

Também é possível utilizar a mesma sintaxe para realizar conversões de tipo, desde que o tipo de origem seja um tipo primitivo ou uma string. Por exemplo, [MyString!Image] converte uma string para o tipo Image do .NET usando o conversor definido no próprio tipo Image. Tanto as operações de cast quanto as conversões de tipo são avaliadas em tempo de execução, podendo resultar em erros fatais para o programa.

A maior parte dos object paths é avaliada quando a UI é criada e os resultados dessas avaliações são armazenados nas propriedades associadas. Entretanto, para os seguintes elementos, é feita uma reavaliação em tempo de execução, conforme necessário:

• Todos os elementos usados nas seções Rules (que definem comportamentos condicionais em tempo de execução);

• No elemento InvokeCommand (usado para invocar métodos);

• No elemento NavigateCommand (usado para navegar entre as páginas MCML).

A principal maneira de fazer binding entre os objetos definidos no assembly gerenciado e os elementos no código MCML é através da utilização das classes derivadas do objeto ModelItem da API do Media Center. O binding pode ser feito de três maneiras diferentes: o ModelItem pode ser a origem do binding (servindo como fonte de dados), destino do binding (servindo como consumidor dos dados do código gerenciado) ou ser feito de tal forma que exista uma comunicação bilateral entre o código gerenciado e o objeto do tipo ModelItem.

Existem diversos objetos que herdam de ModelItem disponíveis na API do Media Center prontos para uso. Esses objetos se dividem em fontes de dados, que podem ser consumidas pelo código gerenciado (ex.: Timer), e em elementos visuais que consomem dados (ex.: EditableText e Choice). O conceito de ModelItem é muito importante para o domínio do desenvolvimento em MCML. Por esta razão, recomenda-se fortemente que a documentação do SDK sobre esse item seja estudada.

Definindo Interfaces com MCML

Como mencionado anteriormente, o principal propósito do MCML é servir como uma forma padronizada de criar interfaces com o usuário que mantenham a “experiência Windows Media Center” uniforme nas aplicações desenvolvidas para ele. O processo de criação pode ser repartido em partes, através da criação de componentes visuais menores que serão usados como base para a criação de interfaces complexas. Além disso, dividir a tarefa em instâncias menores é interessante, pois facilita consideravelmente o reuso de aplicações quando necessário.

Conforme mostrado anteriormente, o nó raiz de um documento MCML é <Mcml>. Dentro deste elemento, cada UI é definida usando o elemento UI. Caso um documento MCML contenha múltiplos elementos deste tipo, apenas o primeiro é exibido. Além disso, um elemento UI deve sempre possuir um nome, além de geralmente conter quatro atributos importantes: Content, Properties, Locals e Rules.

O atributo Content de uma UI contém o aspecto visual desta UI e é baseado em uma árvore de primitivas visuais, ou View Items (detalhadas mais adiante neste artigo), junto com mecanismos padrão de binding de dados. O código a seguir define um painel que pode servir de contêiner para outros elementos visuais:

<Mcml xmlns="http://schemas.microsoft.com/2006/mcml" >
  <UI Name="Exemplo7">
    <Content>
      <Panel Layout="VerticalFlow">
        <Children>
          <Text Content="Este é um Painel com layout vertical." Color="Red" Font="Tahoma,16"/>
          <Text Content="Ele contém dois textos filhos." Color="Blue" Font="Verdana,22"/>
        </Children>
      </Panel>
    </Content>
  </UI>
</Mcml>
	

Já o atributo Properties de uma UI permite parametrizar a interface com propriedades, cada uma das quais consiste em um tipo, um nome e um valor padrão. Uma propriedade pode ter um tipo definido pelo usuário no código gerenciado ou definido em MCML. Além disso, é possível exigir que uma propriedade tenha um valor atribuído pelo componente “pai” ao referenciar o componente “filho”, através do parâmetro $Required, como mostrado a seguir:

<Mcml
    xmlns="http://schemas.microsoft.com/2006/mcml"
    xmlns:cor="assembly://MsCorLib/System"

    <!-- O namespace "Me" é usado para referenciar tipos definidos em outra UI dentro do mesmo arquivo MCML -->
    xmlns:me="Me">

  <UI Name="Exemplo8" BaseUI="me:LabelProperties">
    <Content>
      <Panel Layout="VerticalFlow">
        <Children>
          <me:LabelProperties Label="É necessário colocar algo dentro de Label." />
          <me:LabelProperties Label="Se não for especificado nenhum conteúdo, um erro acontece." />
        </Children>
      </Panel>
    </Content>
  </UI>

  <UI Name="LabelProperties">
    <Properties>
      <!-- Esta propriedade requer que a string Label seja definida quando esta UI for gerenciada 'Label' -->
      <cor:String Name="Label" String="$Required"/>
      <Color Name="ForeColor" Color="Red"/>
    </Properties>

    <Content>
      <Text Name="Display" Content="[Label]" Color="[ForeColor]" Font="Arial,20" />
    </Content>
  </UI>
</Mcml>


	

O atributo Locals de uma UI contém valores privados e objetos que são instanciados para cada instância da UI. Note que esses valores podem ser modificados pela UI em tempo de execução. Os tipos usados em Locals podem ser definidos pelo usuário no assembly .NET ou em MCML.

O atributo Rules, por sua vez, oferece serviços de binding entre componentes que são processados em tempo de execução, além de serem baseados em prioridades, pois a primeira regra que se aplica a um determinado componente é aplicada independente das demais. Cada regra definida em Rules consiste de fontes e alvos, ações e condições. Se um conjunto de condições é avaliado como verdadeiro para uma dada fonte, um conjunto de ações é aplicado ao componente alvo. Desta forma, para manter a consistência, a fonte de uma condição não deveria ser a mesma que o alvo de uma ação na mesma regra.

Existem dois tipos de regras em MCML: as regras “de conveniência”, que são regras simples voltadas para uso em cenários em que há apenas uma fonte e um alvo, e as regras customizadas, que permitem o estabelecimento de condições e ações mais complexas, que fogem ao escopo deste artigo. As principais regras “de conveniência” são:

• Default: são as regras padrão, que possuem uma ação, mas não tem condição estabelecida. São usadas para estabelecer um estado padrão quando nenhuma das outras regras se aplica, ou para estabelecer os valores iniciais do estado quando a UI é inicializada;

• Binding: uma regra deste tipo mapeia um valor fonte a um campo destino. Pode ser usada, por exemplo, para atualizar um label sempre que o valor de uma determinada variável for modificado;

• Condition: uma regra deste tipo checa uma determinada fonte por uma condição, executando a ação caso esta condição seja avaliada como verdadeira;

• Changed: a ação é aplicada se uma determinada fonte sendo monitorada for alterada. Uma condição ou valor não são especificados.

As UIs possuem um modelo de herança interessante que permite que você tire vantagem de funcionalidades comuns em várias UIs. Quando se cria uma UI, é possível herdar todas as propriedades, regras e blocos de conteúdo de outra UI, denominada UI base. Esta característica permite que você reuse estado e comportamento dessas UIs sem ter que reimplementá-los. No código anterior, por exemplo, a UI ‘Exemplo8’ herda da UI ‘LabelProperties’.

Por fim, MCML possui objetos especializados em converter um tipo de valor para outro. Estes objetos são chamados de Transformers, e têm seus principais tipos listados a seguir:

• DateTimeTransformer: convertem um valor DateTime para uma string, para que ela possa ser exibida na tela;

• FormatTransformer: converte um objeto para uma string com o formato que você especificar. Por exemplo, seria possível mostrar “1188001234” em um formato como “(11) 8800-1234”;

• MathTransformer: este elemento faz uma conversão matemática em um valor numérico através da aplicação de operadores matemáticos (multiplicar, dividir, somar, etc);

• Para conhecer outros tipos de elementos transformadores, consulte a documentação do SDK.

Trabalhando com View Items

View Items são as diferentes primitivas visuais que podem ser usadas para criar uma UI. O atributo Content do elemento UI pode conter apenas um elemento Child (“filho”), embora cada View Item também possa conter elementos Child. As seguintes View Items podem ser usadas para projetar uma UI:

• O elemento Clip define uma região de “corte”, que impede desenhos além das suas bordas;

• O elemento ColorFill desenha um retângulo de uma cor sólida, como um fundo;

• O elemento Graphic mostra uma imagem;

• O elemento Host hospeda outra UI, permitindo que se possa colocar uma UI “dentro” de outra;

• O elemento NowPlaying define uma região na qual a miniatura da mídia atual sendo reproduzida no Media Center será mostrada;

• O elemento Panel é um contêiner de layout transparente;

• O elemento Repeater repete uma determinada tag baseado em uma determinada fonte de dados;

• O elemento Scroller permite “rolar” um conteúdo que não cabe em um espaço determinado, para que ele possa ser visualizado completamente;

• Por fim, o elemento Text mostra texto.

Criando Layouts em MCML

Criar um layout é um processo de posicionar e redimensionar itens de acordo com um conjunto de restrições. O layout é definido para cada View Item através da especificação do tipo de layout desejado, estando os principais mostrados a seguir. Vale lembrar que é possível utilizar as opções mostradas a seguir de forma inline, simplificada, ou usar um formato expandido para ter maior controle sobre a disposição dos itens:

• Anchor: dispõe os elementos “filhos” de acordo com pontos “âncora”;

• Center: preenche o espaço colocando os elementos “filhos” um sobre o outro, no centro;

• Dock: organiza os “filhos” ao longo da borda do elemento que os contêm;

• Fill: faz com que o elemento “filho” fique do mesmo tamanho do elemento que o contém;

• Grid: dispõe os “filhos” em um grid;

• HorizontalFlow: dispõe os “filhos” horizontalmente;

• VerticalFlow: dispõe os “filhos” verticalmente.

Caso nenhum layout seja especificado, um layout padrão é aplicado. Por padrão, um View Item é dimensionado de acordo com o tamanho dos seus “’filhos”, sendo o tamanho geral determinado pelo maior dentre estes. É possível, também, criar layouts customizados. Para maiores informações, consulte a documentação do SDK do Media Center.

Gerenciando dispositivos de entrada

MCML pode lidar com diferentes tipos de entrada do usuário (teclado, mouse e controle remoto). Em casos simples, é possível usar Rules para responder a entradas. Por outro lado, é possível usar input handlers (ou gerenciadores de entrada) para responder aos diferentes tipos de entrada de dados, além de ser possível configurar múltiplos handlers em uma mesma UI. Por exemplo, uma UI pode responder tanto a entradas de mouse quanto de controle remoto.

É possível especificar que tipos de dispositivos de entrada são permitidos através do elemento Input. Por exemplo, você pode configurar esta propriedade usando as regras padrão na seção Rules de uma UI, como apresentado no código abaixo. Nesse caso, está se configurando a UI para ser utilizada através do teclado:

<Default Target="[Input.KeyInteractive]" Value="true" >
	

Caso deseje, você pode utilizar os seguintes input handlers para cuidar da interação com mouse e teclado. Estes handlers, que são colocados na seção Locals da UI, dispensam a configuração realizada no código anterior, uma vez que eles próprios configuram estas propriedades:

• ClickHandler: trata entrada com o botão principal do mouse, além das teclas Enter e Espaço do teclado;

• KeyHandler: trata a entrada com teclado, de forma geral;

• MouseWheelHandler: gerencia a ocorrência de movimento na “rodinha” de scroll do mouse;

• ScrollingHandler: trata entradas relacionadas com o ato de “rolar” a tela (em todas as direções);

• ShortcutHandler: gerencia a entrada através do controle remoto;

• TypingHandler: gerencia a entrada em caixas de texto.

O código a seguir mostra o procedimento necessário para detectar e tomar alguma ação quando a tecla Enter for pressionada:

<Mcml
  xmlns="http://schemas.microsoft.com/2006/mcml" >

  <UI Name="Detectando o pressionamento da tecla Enter">

    <!-- Definição das propriedades do objeto -->
    <Properties>
      <Color Name="BackgroundColor" Color="DimGray"/>
      <Color Name="BackgroundPressedColor" Color="White"/>
      <Color Name="LabelColor" Color="White"/>
      <Color Name="LabelPressedColor" Color="Red"/>
    </Properties>

    <Locals>
      <!-- Uso do KeyHandler para detectar a tecla Enter -->
      <KeyHandler Name="EnterHandler" Key="Enter" />
    </Locals>

    <Rules>
      <!-- Regras para definirem o comportamento para quando a tecla Enter for pressionada -->

      <!-- Muda a cor do fundo quando Enter for pressionado -->
      <Condition Source="[EnterHandler.Pressing]" SourceValue="true">
        <Actions>
          <Set Target="[Background.Content]" Value="[BackgroundPressedColor]" />
        </Actions>
      </Condition>

      <!-- Modifica o Label para mostrar que Enter foi pressionado -->
      <Changed Source="[EnterHandler.Invoked]">
        <Actions>
          <Set Target="[Label.Color]" Value="[LabelPressedColor]" />
          <Set Target="[Label.Content]" Value="Enter" />
        </Actions>
      </Changed>

    </Rules>

    <Content>
      <ColorFill Name="Background" Content="[BackgroundColor]" Padding="5,5,5,5"  Layout="VerticalFlow">
        <Children>
          <Text Name="Label" Content="Press Enter" Color="[LabelColor]" Font="Arial,20" Margins="30,30,30,30"/>
        </Children>
      </ColorFill>
    </Content>

  </UI>

</Mcml>

	

Trabalhando com Animações

É possível usar animações dinâmicas em MCML para tornar a experiência do usuário mais interessante nas aplicações Media Center. Em MCML, as animações suportam um modelo baseado em eventos, de tal forma que elas podem ser iniciadas ou paradas de acordo com um evento específico. Em linhas gerais, uma animação é um conjunto de quadros principais como em um filme, que estão associados com um determinado instante no tempo. No entanto, é possível utilizar diversos efeitos e interpolação para criar animações complexas e envolventes.

Uma animação é associada com um View Item através do uso do elemento Animation. O código a seguir mostra uma animação bastante simples, em que uma imagem (Graphic) é movida de um lado para o outro. Três quadros são definidos, cada um dos quais define um tempo e uma posição; em outras palavras, os quadros definem quanto tempo leva para mover a imagem de um quadro para o outro.

<Mcml xmlns="http://schemas.microsoft.com/2006/mcml">

  <UI Name="PositionKeyframe">

    <Content>

      <!-- A imagem que vai se mover -->
      <Graphic Name="Imagem" Content="file://imagem.png">

        <Animations>

          <!-- Cria um loop que vai fazer a imagem se mover para sempre. -->
          <Animation Loop="-1">
            <Keyframes>

              <!-- A posição inicial. -->
              <PositionKeyframe Time="0.0" Value="0,0,0"/>

              <!-- Move a imagem para a direita ao longo do tempo de 1 segundo. -->
              <PositionKeyframe Time="1.0" Value="200,0,0"/>

              <!-- Move a imagem de volta à posição inicial, mas desta vez ao longo de 8 segundos. -->
              <PositionKeyframe Time="8.0" Value="0,0,0"/>

            </Keyframes>
          </Animation>
        </Animations>
      </Graphic>
    </Content>
  </UI>
</Mcml>
	

Distribuindo Aplicações Media Center através da Web

Nem sempre é possível (ou conveniente) instalar aplicações desenvolvidas para o Windows Media Center no computador do usuário. Dois exemplos típicos são os cenários em que o usuário acessa um conteúdo dinâmico, que muda com freqüência, ou nos casos em que existem restrições físicas para acessar o PC com o Media Center.

Uma forma alternativa e bastante interessante de distribuir programas MCML é através da Web. Nesse caso, o Windows Media Center funciona como uma espécie de navegador que acessa a aplicação armazenada em um servidor na internet, sem que qualquer código seja armazenado no computador do usuário. Para ele, a aplicação aparece e é acessada da mesma forma que aquelas instaladas localmente, como através do menu Programas. O desenvolvedor, no entanto, deve ter em mente que nem todos os tipos do .NET Framework estão disponíveis para uso em aplicações Media Center que estão na Web. Os tipos suportados estão listados na documentação do SDK.

Essa forma de distribuição é idêntica à forma que aplicações Web comuns são distribuídas, compartilhando, portanto, a mesma garantia de que os usuários sempre recebem a versão mais atualizada da aplicação. Além disso, elas podem ser registradas para uso no Media Center da mesma forma que outros tipos de soluções para a plataforma, através do uso do programa “RegisterMCEApp.exe” (localizado em %Windir%\ehome) ou do método RegisterApplication do SDK.

Como dito anteriormente, as aplicações MCML armazenadas em servidores Web funcionam como aplicações Web convencionais, podendo navegar por outras “páginas” MCML dentro do servidor. Os elementos Navigate e NavigateCommand suportam navegação Web da mesma forma que suportam a navegação baseada em recursos ou baseadas em arquivos. Através do atributo Data desses elementos, é possível passar dados para as telas de destino.

Existem casos em que é interessante atualizar os dados de uma página sem que a página tenha que ser recarregada por completo. Por exemplo, você pode querer atualizar os dados de uma página cheia de recursos que você não quer baixar novamente, ou evitar que o usuário perceba que a aplicação “piscou” enquanto a página é recarregada. O View Item Host pode ser usado para obter essa funcionalidade. Para maiores informações, consulte a documentação do SDK.

Requisições ao servidor podem ser feitas da mesma forma que a submissão de formulários, usando os comandos GET e POST. Para proteger os dados enviados ao servidor, no entanto, é necessário utilizar o protocolo SSL (Secure Sockets Layer) para criptografar os dados ao se usar o comando POST. Além disso, uma aplicação instalada localmente no Media Center não pode navegar diretamente para uma página MCML localizada em um servidor HTTP.

Em linhas gerais, não há restrições para os locais de onde conteúdo multimídia, como imagens, sons e vídeos, serão carregados, podendo estar localizados em qualquer lugar da internet. Entretanto, mais uma vez devido a razões de segurança, outros elementos MCML precisam estar localizados no mesmo domínio em que o elemento MCML original foi carregado.

Conclusão

Neste artigo, apresentamos a Media Center Markup Language, linguagem baseada em XML para definição de interfaces no Windows Media Center. Foram mostradas as principais tags utilizadas na criação de aplicações com visual rico no Media Center, bem como as formas de comunicação da MCML com código gerenciado, de modo a fornecer um ponto de partida interessante àqueles que desejarem desenvolver para essa nova e instigante plataforma.

Para mais informações

Download do Windows Media Center SDK - http://www.microsoft.com/downloads/details.aspx?familyid=a43ea0b7-b85f-4612-aa08-3bf128c5873e&displaylang=en

Documentação Online do Windows Media Center SDK - http://msdn2.microsoft.com/en-us/library/ms818424.aspx

Blog do time de desenvolvimento do Windows Media Center - http://blog.mediacentersandbox.com/

Sobre o Autor

Carlos Eduardo Rodrigues (carlos.rodrigues@partecweb.com.br), Microsoft Student Partner Lead/PE, é engenheiro de software da Partec, mestrando e bacharel em Ciência da Computação pela UFPE, vice-campeão mundial da competição Microsoft Imagine Cup 2006 e campeão mundial da Imagine Cup 2007. Trabalha com tecnologia Microsoft desde 2002, tendo obtido certificações MCTS em várias tecnologias de desenvolvimento, além de certificação MCITP em Windows Vista.