Como ler o ficheiro manifest usando o Cimbalino Windows Phone Toolkit (usando MVVM)

Este artigo tem como objectivo mostrar como ler o ficheiro manifesto de uma aplicação Windows Phone, usando o  Cimbalino Windows Phone Toolkit Background, mais especificamente o ApplicationManifestService.

Introdução

Cimbalino Windows Phone Toolkit é um conjunto de itens úteis e poderosos para ajudar na implementação de aplicações Windows Phone, especialmente nas aplicações que implementem o padrão MVVM. O projeto base do toolkit contém serviços para implementação do padrão de MVVM, conversores, classes auxiliares, métodos de extensões.

O Cimbalino.Phone.Toolkit.Background – é o projeto do toolkit contendo serviços para implementação do padrão de MVVM compatível com background agents. Este inclui o IApplicationManifestService – que representa a interface para o serviço com a capacidade de ler o ficheiro manifest da aplicação.  A implementação é ApplicationManifestService.

Ecrã do Exemplo

Cibalino: exemplo de leitura do manifest

Construindo o exemplo

O código fonte pode ser obtido em Exemplo ApplicationManifestService (inclui exemplo para os vários targets).

Os pacotes estão disponíveis em Nuget Package Manager (para ambos os targets) e podem ser instalados.

O Exemplo

Registando serviços

Devemos começar por registar cada serviço no ViewModelLocator, como podemos ver de seguida:

    /// <summary>
    /// This class contains static references to all the view models in the
    /// application and provides an entry point for the bindings.
    /// </summary>
    public class ViewModelLocator
    {
        /// <summary>
        /// Initializes a new instance of the ViewModelLocator class.
        /// </summary>
        public ViewModelLocator()
        {
            ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
   
            if (!SimpleIoc.Default.IsRegistered())
            {
                SimpleIoc.Default.Register<IApplicationManifestService, ApplicationManifestService>();
            }
            SimpleIoc.Default.Register();
        }
   
        public MainViewModel MainViewModel
        {
            get
            {
                return ServiceLocator.Current.GetInstance();
            }
        }
           
        public static void Cleanup()
        {
            // TODO Clear the ViewModels
        }
    }

Implementando a ViewModel

Em seguinda devemos implementar o MainViewModel, como podemos ver de seguida:

    /// <summary>
    /// This class contains properties that the main View can data bind to.
    /// </summary>
    public class MainViewModel : ViewModelBase
    {
        /// <summary>
        /// The public application url.
        /// </summary>
        private readonly string _appUrl;
   
        /// <summary>
        /// The application manifest.
        /// </summary>
        private readonly ApplicationManifest _applicationManifest;
   
        /// <summary>
        /// Initializes a new instance of the  class.
        /// </summary>
        /// <param>
        /// The email Compose Service.
        /// </param>
        /// <param>
        /// The application Manifest Service.
        /// </param>
        /// <param>
        /// The marketplace review service
        /// </param>
        /// <param>
        /// The share Link Service.
        /// </param>
        public MainViewModel(IApplicationManifestService applicationManifestService)
        {
            _applicationManifest = applicationManifestService.GetApplicationManifest();
            _appUrl = string.Concat("http://windowsphone.com/s?appid= This link is external to TechNet Wiki. It will open in a new window. ", _applicationManifest.App.ProductId);
        }
   
        /// <summary>
        /// Gets the title.
        /// </summary>
        public string Title
        {
            get
            {
                return _applicationManifest.App.Title;
            }
        }
   
        /// <summary>
        /// Gets the author.
        /// </summary>
        public string Author
        {
            get
            {
                return _applicationManifest.App.Author;
            }
        }
   
        /// <summary>
        /// Gets the version.
        /// </summary>
        public string Version
        {
            get
            {
                return _applicationManifest.App.Version;
            }
        }
   
        /// <summary>
        /// Gets the description.
        /// </summary>
        public string Description
        {
            get
            {
                return _applicationManifest.App.Description;
            }
        }
   
        /// <summary>
        /// Gets the product ID.
        /// </summary>
        public string ProductID
        {
            get
            {
                return _applicationManifest.App.ProductId;
            }
        }
   
        /// <summary>
        /// Gets the publisher.
        /// </summary>
        public string Publisher
        {
            get
            {
                return _applicationManifest.App.Publisher;
            }
        }
   
        /// <summary>
        /// Gets the capabilities.
        /// </summary>
        public IList Capabilities
        {
            get
            {
                return _applicationManifest.App.Capabilities.ToList();
            }
        }
    }
}

Implementando a View

Para conetar a view model com a página devemos adicionar a ViewModelLocator no App.xaml:

<vm:ViewModelLocator x:Key="Locator" d:IsDataSource="True" /> 

e adicionar o binding na página principal:

DataContext="{Binding MainViewModel,
                 Source={StaticResource Locator}}"

A MainPage.xaml será algo do género:

<phone:PhoneApplicationPage x:Class="CimbalinoSample.MainPage"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
        xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
        DataContext="{Binding MainViewModel, Source={StaticResource Locator}}"
        FontFamily="{StaticResource PhoneFontFamilyNormal}"
        FontSize="{StaticResource PhoneFontSizeNormal}"
        Foreground="{StaticResource PhoneForegroundBrush}"
        Orientation="Portrait"
        SupportedOrientations="Portrait"
        shell:SystemTray.IsVisible="True"
        mc:Ignorable="d">
   
    <!--  LayoutRoot is the root grid where all page content is placed  -->
    <Grid x:Name="LayoutRoot" Background="Transparent">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
   
   
        <!--  TitlePanel contains the name of the application and page title  -->
        <StackPanel x:Name="TitlePanel"
                    Grid.Row="0"
                    Margin="12,17,0,28">
            <TextBlock Margin="12,0"
                       Style="{StaticResource PhoneTextTitle2Style}"
                       Text="Cimbalino Sample" />
        </StackPanel>
   
        <!--  ContentPanel - place additional content here  -->
        <Grid x:Name="ContentPanel"
              Grid.Row="1"
              Margin="12,0,12,0" >
            <TextBlock TextWrapping="Wrap"
                       VerticalAlignment="Top" Height="50">
                Title: <Run Text="{Binding Title}"/>
                </TextBlock>
            <TextBlock TextWrapping="Wrap"
                       VerticalAlignment="Top" Margin="0,50,0,0">
                Author: <Run Text="{Binding Author}"/>
            </TextBlock>
            <TextBlock TextWrapping="Wrap"
                       VerticalAlignment="Top" Margin="0,100,0,0">
                Version: <Run Text="{Binding Version}"/>
            </TextBlock>
            <TextBlock TextWrapping="Wrap"
                       VerticalAlignment="Top" Margin="0,150,0,0">
                Description: <Run Text="{Binding Description}"/>
            </TextBlock>
            <TextBlock TextWrapping="Wrap"
                       VerticalAlignment="Top" Margin="0,300,0,0">
                ProductID: <Run Text="{Binding ProductID}"/>
            </TextBlock>
            <TextBlock TextWrapping="Wrap"
                       VerticalAlignment="Top" Margin="0,350,0,0">
                Publisher: <Run Text="{Binding Publisher}"/>
            </TextBlock>
            <TextBlock TextWrapping="Wrap" Text="Capabilities:"
                       VerticalAlignment="Top" Margin="0,400,0,0"/>
            <ListBox DisplayMemberPath="Name" Margin="0,450,0,0"
                     ItemsSource="{Binding Capabilities}"/>
        </Grid>
   
    </Grid>
   
</phone:PhoneApplicationPage>

Conclusão

Em conclusão, podemos constatar que através dos toolkits usados é muito simples obter a informação do ficheiro manifest e estes ajudam na implementação do padrão de desenvolvimento MVVM, simplificando o desenvolvimento das aplicações.

Publicado na edição 46 (PDF) da Revista PROGRAMAR.