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
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.