Exportar (0) Imprimir
Expandir Tudo

Windows App - Windows Store

Por Renato Haddad

Maio, 2013

Dn175728.060DE5057573180CEC6D227C6D3E2207(pt-br,MSDN.10).png

Visão Geral

Uma das razões mais fortes para escrever aplicações no estilo Modern UI é a facilidade com que você pode publicá-las na Windows Store (loja do Windows). Com mais de 500 milhões de PCs em todo o mundo que atualmente executam o Windows 7, e cada um dos PCs representam um potencial upgrade para o Windows 8, o mercado - e potencial de receita - é ao mesmo tempo enorme e diversificado. Com um modelo de negócio das receitas que direciona até 80% das receitas de vendas para o autor, não há falta de motivação para os desenvolvedores escreverem aplicações grandes e oferecê-las ao mundo. A loja tem opções de monetização muito flexíveis: Você pode fazer versões Trials (degustação), compra única, em app-compras, comércio de componentes e propaganda.

Para os trials você pode usar o namespace Windows.ApplicationModel.Store das APIs do Windows Store para detectar se o aplicativo está sendo executado em licença de teste. WinRT também oferece outras APIs que facilitam a atualização de versões de teste para versões pagas, suporte para compras de produtos adicionais, obter informações de licença, e muito mais. A classe CurrentAppSimulator do Windows Runtime fornece um código para simular compras e testes baseados nas APIs do Windows Store em um ambiente controlado.

Neste laboratório, você usará as APIs do Windows Store para monetizar o Cardápio Eletrônico.

Primeiro você irá modificar a caixa de texto para detectar versões de teste e incluir um botão de compra se o aplicativo não foi pago. Em seguida, você vai usar CurrentAppSimulator para simular uma compra, quando botão de compra é clicado. Finalmente, você vai simular compras adicionais de itens, oferecendo receitas italianas como adicional pago ao invés de gratuito.

Dn175728.3B941C88DD1DDDBACE3C6B22FCEC0088(pt-br,MSDN.10).png

Objetivos

Neste lab você aprenderá:

  • Detectar se o seu aplicativo está sendo executado como uma versão de teste
  • Simular compras
  • Simular compras do aplicativo de dentro do próprio aplicativo
  • Simular compras de produtos adicionais
  • Recuperar as informações de licenciamento sobre a aplicação e produtos

Requirementos do Sistema

Você deverá ter os seguintes itens para completar os exercícios:

  • Microsoft Windows 8
  • Microsoft Visual Studio 2012 RC

Configuração

Você deverá seguir estes passos para preparar o seu computador para estes exercícios:

  • Instalar o Microsoft Windows 8
  • Instalar o Microsoft Visual Studio 2012 RC

Exercício 1: Detectar Versão Teste

Neste exercício, você usará as APIs do Windows Runtime para personalizar o conteúdo da página Sobre do Cardápio Eletrônico. Se o aplicativo tiver sido adquirido, você exibirá as informações de licenciamento. Se não foi comprado, ou seja, se estiver executando como uma versão de teste, então você exibirá o botão compra. Além disso, o preço exibido no botão de compra não vai ser codificado, mas virá a partir de informações recuperadas da loja do Windows.

Tarefa 1 – Adicionar o WindowsStoreProxy.xml

Vamos usar a classe CurrentAppSimulator para simular compras, obter informações de licença, e muito mais. Para tornar a simulação o mais realista possível, usaremos um arquivo chamado WindowsStoreProxy.xml para fornecer informações sobre preços, datas de validade e muito mais para CurrentAppSimulator.

  • Abra o projeto do Cardápio Eletrônico.
  • Se o projeto não tiver uma pasta chamada Data, então crie.
  • Clique com o botão direito na pasta Data e selecione Add - Existing Item para importar o arquivo license.xml da pasta Assets/Data dos materiais iniciais deste projeto. Um meio mais rápido é arrastar o arquivo diretamente do Windows Explorer para a pasta Data. Este é o arquivo a partir do qual vamos criar WindowsStoreProxy.xml.
  • Abra o arquivo App.xaml.cs e localize o método OnLaunched.
  • Adicione os seguintes códigos logo após a inscrição da notificação.
#region Simular compras
// Initialize WindowsStoreProxy.xml
var folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Microsoft\\Windows Store\\ApiData", CreationCollisionOption.OpenIfExists);
var file = await Package.Current.InstalledLocation.GetFileAsync("Data\\license.xml");
var newfile = await folder.CreateFileAsync("WindowsStoreProxy.xml", CreationCollisionOption.ReplaceExisting);
await file.CopyAndReplaceAsync(newfile);
#endregion
Dn175728.note(pt-br,MSDN.10).gifNota:
O código que você acabou de adicionar usa a API de armazenamento do Windows Runtime para criar WindowsStoreProxy.xml no local específico em que CurrentAppSimulator espera encontrá-lo, e copia o conteúdo de license.xml cada vez que o aplicativo é iniciado. Você pode simular compras de aplicativos e compras de produtos sem um arquivo de proxy, mas se você quiser uma rica simulação que recupera os preços e outras informações, você deve incluir WindowsStoreProxy.xml.

  • Abra o arquivo license.xml e inspecione seu conteúdo. O elemento <ListingInformation> contém informações sobre o aplicativo em si e sobre os produtos de receitas italiana, o qual vamos oferecer para compra no Exercício 3. <LicenseInformation> contém informações de licenciamento sobre a aplicação e o produto. Na vida real, todas estas informações virão da Loja do Windows. Numa simulação, no entanto, a informação vem de WindowsStoreProxy.xml
<?xml version="1.0" encoding="utf-16" ?>
<CurrentApp>
  <ListingInformation>
    <App>
      <AppId>2B14D306-D8F8-4066-A45B-0FB3464C67F2</AppId>
      <LinkUri>http://apps.microsoft.com/app/2B14D306-D8F8-4066-A45B-0FB3464C67F2</LinkUri>
      <CurrentMarket>en-US</CurrentMarket>
      <AgeRating>3</AgeRating>
      <MarketData xml:lang="en-us">
        <Name>Contoso Cookbook</Name>
        <Description>Metro recipes for Metro developers</Description>
        <Price>12.99</Price>
        <CurrencySymbol>$</CurrencySymbol>
      </MarketData>
    </App>
    <Product ProductId="ItalianRecipes">
      <MarketData xml:lang="en-us">
        <Name>Italian Recipes</Name>
        <Price>0.99</Price>
        <CurrencySymbol>$</CurrencySymbol>
      </MarketData>
    </Product>
  </ListingInformation>
  
  <LicenseInformation>
    <App>
      <IsActive>true</IsActive>
      <IsTrial>true</IsTrial>
      <ExpirationDate>2022-12-31T23:59:59.00Z</ExpirationDate>
    </App>
    <Product ProductId="ItalianRecipes">
      <IsActive>false</IsActive>
    </Product>
  </LicenseInformation>
</CurrentApp>

Tarefa 2 – Modificar a Página Sobre

Agora vamos modificar a página sobre criada em laboratório 5. Atualmente o texto "Versão Trial" aparece abaixo do título da aplicação na página Sobre. Usaremos as APIs da loja para determinar se esta é realmente uma versão de teste e personalizar o conteúdo da página com base nos resultados.

  • O primeiro passo é adicionar uma classe sobre a licença. Na pasta DataModel, no Solution Explorer, dê um clique com o botão direito e selecione Add – Class. O nome da classe será AppLicenseDataSource.cs, conforme a Figura 1.

Dn175728.C6AB3E1F11B13697274E83CFECEEF5C3(pt-br,MSDN.10).png

Figura 1 – Nova classe

  • Substitua todo o conteúdo desta classe pelo seguinte código.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.ApplicationModel.Store;
using Windows.Foundation;

namespace ContosoCookbook
{
    class AppLicenseDataSource : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private bool _licensed = false;
        private string _price;

        public AppLicenseDataSource()
        {
            if (CurrentAppSimulator.LicenseInformation.IsTrial)
            {
                CurrentAppSimulator.LicenseInformation.LicenseChanged += OnLicenseChanged;
                GetListingInformationAsync();
            }
            else
                _licensed = true;
        }

        private async void GetListingInformationAsync()
        {
            var listing = await CurrentAppSimulator.LoadListingInformationAsync();
            _price = listing.FormattedPrice;
        }

        private void OnLicenseChanged()
        {
            if (!CurrentAppSimulator.LicenseInformation.IsTrial)
            {
                _licensed = true;
                CurrentAppSimulator.LicenseInformation.LicenseChanged -= OnLicenseChanged;

                if (PropertyChanged != null)
                {
                    PropertyChanged(this, new PropertyChangedEventArgs("IsLicensed"));
                    PropertyChanged(this, new PropertyChangedEventArgs("IsTrial"));
                    PropertyChanged(this, new PropertyChangedEventArgs("LicenseInfo"));
                }
            }
        }

        public bool IsLicensed
        {
            get { return _licensed; }
        }

        public bool IsTrial
        {
            get { return !_licensed; }
        }

        public string LicenseInfo
        {
            get
            {
                if (!_licensed)
                    return "Versão Trial";
                else
                    return ("Valida até " + CurrentAppSimulator.LicenseInformation.ExpirationDate.LocalDateTime.ToString("dddd, MMMM d, yyyy"));
            }
        }

        public string FormattedPrice
        {
            get
            {
                if (!String.IsNullOrEmpty(_price))
                    return "Atualizar para a versão completa por " + _price;
                else
                    return "Atualizado para a verão completa";
            }
        }
    }
}
  • Veja na Figura 2 a estrutura da classe AppLicenseDataSource com as propriedades (FormattedPrice, IsLicensed, IsTrial e LicenseInfo) e os métodos (AppLicenseDataSource, GetListingInformationAsync e OnLicenseChanged).

Dn175728.2869E2018C261381A7FBB447E71C43DE(pt-br,MSDN.10).png

Figura 2 – Classe de gerenciamento da licença

Dn175728.note(pt-br,MSDN.10).gifNota:
A classe AppLicenseDataSource implementa INotifyPropertyChanged e expõe o Binding das propriedades chamadas IsLicensed, IsTrial, LicenseInfo e FormattedPrice. As duas primeiras usam o CurrentAppSimulator.LicenseInformation.IsTrial para determinar se o aplicativo que está sendo executado usa uma versão comprada ou de teste. LicenseInfo retorna o texto "Versão Trial" se o aplicativo é de teste ou o texto com a data de validação da licença, se não é. FormattedPrice retorna um texto no botão contendo o preço da aplicação, que é obtido a partir da loja do Windows (ou, neste caso, WindowsStoreProxy.xml). Informações sobre os preços vem do objeto ListingInformation recuperado com CurrentAppSimulator.LoadListingInformationAsync.

  • Selecione o menu Build / Build Solution para compilar a solução. No rodapé do Visual Studio deverá constar a mensagem “”Build succeeded”. Com isto, já podemos usar esta classe no projeto.
  • Abra a página AboutUserControl.xaml e adicione o seguinte atributo, destacado em amarelo, na lista dos namespaces do XAML no topo da página. Aqui é um ponto chave para quem desenvolve em XAML, pois temos uma referência no XAML de uma classe em C#.
<UserControl
    x:Class="ContosoCookbook.AboutUserControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:ContosoCookbook"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:common="using:ContosoCookbook.Common"
    mc:Ignorable="d"
    d:DesignHeight="300"
    d:DesignWidth="400">
  • Agora adicione os seguintes códigos exatamente acima do elemento Grid. Isto irá atribuir recursos para a página atual, ou seja, há uma referência para a classe AppLicenseDataSource, onde a chave é License e a classe BooleanToVisibilityConverter com o mesmo nome para a chave.
<UserControl.Resources>
    <local:AppLicenseDataSource x:Key="License" />
    <common:BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>
</UserControl.Resources>
Dn175728.note(pt-br,MSDN.10).gifNota:
BooleanToVisibilityConverter é um conversor de valor simples que converte o valor booleano verdadeiro em Visibility.Visible, e falso em Visibility.Collapsed. Ele foi incluído quando o projeto foi criado pelo Visual Studio, pois é comum usarmos este conversor nos projetos. No XAML, para mostrar ou ocultar um objeto, usamos o Visible ou o Collapsed da propriedade Visibility.

  • Altere o texto “Versão Trial” do TextBlock para os seguintes códigos.
<TextBlock Text="{Binding LicenseInfo, Source={StaticResource License}}" 
            FontFamily="Segoe UI" FontWeight="SemiLight" 
            FontSize="18" TextWrapping="Wrap" />
<Button x:Name="PurchaseButton" Width="225" Height="120" Margin="0,24,0,0" 
        Visibility="{Binding IsTrial, Source={StaticResource License}, Converter={StaticResource BooleanToVisibilityConverter }}">
    <Button.Content>
        <TextBlock Text="{Binding FormattedPrice, Source={StaticResource License}}" 
                    TextWrapping="Wrap" TextAlignment="Center" />
    </Button.Content>
</Button>
  • Este é um bloco de códigos que merece total atenção e uma explicação detalhada. Como resultado, o botão só irá aparecer na página se o aplicativo for uma versão de teste.
<!-- O atributo Text (que exibe o texto) do TextBlock deixou de ser fixo (Versão Trial), agora vem a partir da propriedade LicenseInfo do objeto AppLicenseDataSource. Isto é possível porque o Source aponta para o recurso (StaticResource) com a chave License, adicionado no item anterior na lista de <UserControl.Resources>. Sendo assim, basta usar a palavra chave Binding seguido da propriedade do objeto, neste caso, LicenseInfo-->
<TextBlock Text="{Binding LicenseInfo, Source={StaticResource License}}" 
            <!-- Configurações da fonte, sendo que o TextWrapping=Wrap quebra o texto automaticamente de acordo com a largura disponível do objeto -->
            FontFamily="Segoe UI" FontWeight="SemiLight" 
            FontSize="18" TextWrapping="Wrap" />

<!-- Este botão pode ser visível ou não. Quem determina isto é o atributo Visibility que faz o Binding para a propriedade IsTrial do mesmo objeto AppLicenseDataSource. Como foi declarado o conversor Converter BooleanToVisibilityConverter que retorna Visible ou Collapsed para exibir ou não o botão em si. -->
<Button x:Name="PurchaseButton" Width="225" Height="120" Margin="0,24,0,0" 
        Visibility="{Binding IsTrial, Source={StaticResource License}, Converter={StaticResource BooleanToVisibilityConverter }}">
    <Button.Content>
        <!-- O botão contém um TextBlock onde o texto faz o Binding para a propriedade FormattedPrice -->
        <TextBlock Text="{Binding FormattedPrice, Source={StaticResource License}}" 
                    TextWrapping="Wrap" TextAlignment="Center" />
    </Button.Content>
</Button>

Tarefa 3 – Testar os Resultados

Chegou a hora de testar os códigos e ver em ação o CurrentAppSimulator e o WindowsStoreProxy.xml.

  • Pressione F5 para executar a aplicação.
  • Exiba a barra de Charms (Win + C) e selecione a opção Configurações.
  • Selecione a opção Sobre no menu para exibir a página Sobre.
  • Confirme que o botão de compra aparece mostrando o preço de $12.99, conforme a Figura 3.

Dn175728.9B41F0860C44E9F8E73DE706EA4085B2(pt-br,MSDN.10).png

Figura 3 – Janela Sobre com a versão Trial

  • Retorne ao Visual Studio e pare a execução.
  • Abra o arquivo license.xml e altere o preço de compra no elemento <Price> na seção <App> de $12.99 para $8.99.
<App>
    <AppId>2B14D306-D8F8-4066-A45B-0FB3464C67F2</AppId>
    <LinkUri>http://apps.microsoft.com/app/2B14D306-D8F8-4066-A45B-0FB3464C67F2</LinkUri>
    <CurrentMarket>en-US</CurrentMarket>
    <AgeRating>3</AgeRating>
    <MarketData xml:lang="en-us">
      <Name>Contoso Cookbook</Name>
      <Description>Metro recipes for Metro developers</Description>
      <Price>8.99</Price>
      <CurrencySymbol>$</CurrencySymbol>
    </MarketData>
  </App>
  • Execute a aplicação novamente e veja que o preço da aplicação mudou conforme o novo valor.
  • Retorne ao Visual Studio novamente e pare a execução.
  • Abra o arquivo license.xml novamente e altere o preço de volta para $12.99.
  • Altere o elemento <IsTrial> de true para false.
<LicenseInformation>
  <App>
    <IsActive>true</IsActive>
    <IsTrial>false</IsTrial>
    <ExpirationDate>2022-12-31T23:59:59.00Z</ExpirationDate>
  </App>
  <Product ProductId="ItalianRecipes">
    <IsActive>false</IsActive>
  </Product>
</LicenseInformation>
  • Execute a aplicação e vá para a página Sobre. Note que o botão comprar se foi e agora você vê a mensagem “Valida até Saturday, December 31, 2022”, conforme a Figura 4.

Dn175728.EEE39532CB2EA099B8A51969948A8326(pt-br,MSDN.10).png

Figura 4 – Versão completa da aplicação

  • Retorne ao Visual Studio e pare a execução.
  • Em preparação para o próximo exercício, altere o elemento <IsTrial> de false para true no arquivo license.xml.
<LicenseInformation>
  <App>
    <IsActive>true</IsActive>
    <IsTrial>true</IsTrial>
    <ExpirationDate>2022-12-31T23:59:59.00Z</ExpirationDate>
  </App>
  <Product ProductId="ItalianRecipes">
    <IsActive>false</IsActive>
  </Product>
</LicenseInformation>

Exercício 2: Simular Compras

Você pode usar o arquivo WindowsStoreProxy.xml para testar alterações na UI com base se o aplicativo é uma versão de teste, mas isso não é substituto para ser capaz de simular compras reais. Neste exercício, você vai escrever um manipulador para o botão de compra para que você possa "comprar" o aplicativo na loja do Windows.

Tarefa 1 – Código Para Comprar

Para simular as compras na aplicação, chamaremos o CurrentAppSimulator.RequestAppPurchaseAsync quando o usuário clicar no botão comprar na página Sobre.

Dn175728.note(pt-br,MSDN.10).gifNota:
O método RequestPurchaseAppAsync envia uma solicitação assíncrona para comprar o aplicativo da loja do Windows. Para determinar quando o usuário compra o aplicativo, você deverá programar eventos para o LicenseChanged. Quando esse evento é disparado, você pode verificar se a compra foi feita através da verificação CurrentAppSimulator.LicenseInformation.IsTrial.

  • Abra o arquivo AboutUserControl.xaml.
  • Adicione o seguinte código destacado em amarelo para o atributo Click do botão Comprar (PurchaseButton). Quando o usuário clicar neste botão, será disparado o método OnPurchaseButtonClicked.
<Button x:Name="PurchaseButton" Width="225" Height="120" Margin="0,24,0,0" 
        Visibility="{Binding IsTrial, Source={StaticResource License}, Converter={StaticResource BooleanToVisibilityConverter }}"
        Click="OnPurchaseButtonClicked">
  • Pressione F7 para mostrar os código C# desta página (AboutUserControl.xaml.cs) e adicione o seguinte código na lista de using no topo do arquivo.
using Windows.ApplicationModel.Store;
  • Como declaramos a chamada do método OnPurchaseButtonClicked no botão comprar, adicione o seguinte código para simular a compra.
private void OnPurchaseButtonClicked(object sender, RoutedEventArgs e)
{
    // Purchase the app
    CurrentAppSimulator.RequestAppPurchaseAsync(false);
}
Dn175728.note(pt-br,MSDN.10).gifNota:
RequestAppPurchaseAsync é um método assíncrono. Para determinar se a compra foi realizada, você manipula os eventos LicenseChanged. Você não está disparando esses eventos aqui, porque você já está os fez em AppLicenseDataSource.cs. Quando o LicenseChanged é disparado, o manipulador verifica se o aplicativo não é mais uma versão de teste e dispara o PropertyChanged para atualizar controles vinculados as propriedades do AppLicenseDataSource.

Tarefa 2 – Compra na Aplicação

Agora vamos simular uma compra na aplicação. Esteja ciente de que o CurrentAppSimulator armazena na memória as informações sobre as compras e mudanças no status de licenciamento, mas não grava no WindowsStoreProxy.xml. Portanto, uma vez que você compra o aplicativo, ele vai permanecer "comprado", enquanto o aplicativo está rodando, mas quando você reiniciar o aplicativo, você mais uma vez executará uma versão de teste.

  • Pressione F5 para rodar a aplicação.
  • Vá para a página Sobre e clique no botão comprar para simular uma compra, conforme a Figura 5.

Dn175728.3B941C88DD1DDDBACE3C6B22FCEC0088(pt-br,MSDN.10).png

Figura 5 – Botão comprar

Será exibida a janela da Windows Store, conforme a Figura 6, para simular a compra. Clique no botão Continuar.

Dn175728.70EF9E47658B698680B25C72EFBEB0A5(pt-br,MSDN.10).png

Figura 6 – Efetuar a compra

  • Exiba novamente a página Sobre e veja que o botão desapareceu, contendo apenas o texto com a data de expiração, conforme a Figura 7.

Dn175728.68CEF4CB2B6843A674A226980CD1D430(pt-br,MSDN.10).png

Figura 7 – Compra efetuada

Dn175728.note(pt-br,MSDN.10).gifNote:
O Cardápio Eletrônico não expõe a funcionalidade adicional para o usuário uma vez que foi comprado, mas apenas substitui o botão de compra com as informações de licenciamento. Na vida real, você pode optar por limitar o que o usuário pode fazer com uma versão de teste e apenas expor a funcionalidade completa, uma vez por compra foi feita.

Exercício 3: Simular Compra do Produto

Além de permitir a compra única do aplicativo, o Windows Store suporta a compra de produtos sob demanda também. Por exemplo, um aplicativo de jogo poderia permitir que os usuários comprassem níveis adicionais do jogo assim que completar os níveis anteriores. No modelo de objetos da Windows Store, recursos adquiridos desta forma são conhecidos como produtos e o Windows Runtime fornece as APIs necessárias para estas compras de produtos, bem como APIs para determinar quais produtos foram comprados, o status de licenciamento desses produtos, e muito mais.

Neste exercício, você modificará o Cardápio Eeltrônico para que receitas italianas não sejam mais livres, e sim compradas. Você irá adicionar uma simples interface de usuário para comprá-las, baseadas no CurrentAppSimulator, assim como a lógica que impede que receitas italianas serem mostradas na íntegra, depois de uma compra do produto foi feita.

Tarefa 1 – Modificar a Página de Detalhes

O primeiro passo é adicionar uma classe de fonte de dados para fornecer informações de licenciamento do produto. Então, vamos adicionar um botão de compra e usar o Binding para se certificar de que, para receitas italianas, ou o botão de compra ou instruções da receita são exibidos, mas não ambos. Finalmente, vamos adicionar o código ao botão de compra, permitindo a compra na aplicação.

  • No Solution Explorer, clique com o botão direito na pasta DataModel e selecione Add / Class. Digite ProductLicenseDataSource.cs no nome do arquivo e clique no botão Add.
  • Substitua todo o conteúdo do arquivo com os seguintes códigos.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.ApplicationModel.Store;

namespace ContosoCookbook
{
    class ProductLicenseDataSource : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private const string _name = "ItalianRecipes";
        private bool _licensed = false;
        private string _price;

        public string GroupTitle
        {
            set
            {
                if (value != "Italian")
                    _licensed = true;
                else if (CurrentAppSimulator.LicenseInformation.ProductLicenses[_name].IsActive)
                    _licensed = true;
                else
                {
                    CurrentAppSimulator.LicenseInformation.LicenseChanged += OnLicenseChanged;
                    GetListingInformationAsync();
                }
            }
        }

        private async void GetListingInformationAsync()
        {
            var listing = await CurrentAppSimulator.LoadListingInformationAsync();
            _price = listing.ProductListings[_name].FormattedPrice;
        }

        private void OnLicenseChanged()
        {
            if (CurrentAppSimulator.LicenseInformation.ProductLicenses[_name].IsActive)
            {
                _licensed = true;
                CurrentAppSimulator.LicenseInformation.LicenseChanged -= OnLicenseChanged;

                if (PropertyChanged != null)
                {
                    PropertyChanged(this, new PropertyChangedEventArgs("IsLicensed"));
                    PropertyChanged(this, new PropertyChangedEventArgs("IsTrial"));
                }
            }
        }

        public bool IsLicensed
        {
            get { return _licensed; }
        }

        public bool IsTrial
        {
            get { return !_licensed; }
        }

        public string FormattedPrice
        {
            get
            {
                if (!String.IsNullOrEmpty(_price))
                    return "Comprar receitas Italianas por " + _price;
                else
                    return "Compra receitas Italianas";
            }
        }
    }
}
Dn175728.note(pt-br,MSDN.10).gifNota:
ProductLicenseDataSource é semelhante à classe AppLicenseDataSource adicionada anteriormente. Considerando que a classe AppLicenseDataSource encapsula dados sobre o estado do licenciamento do aplicativo, a classe ProductLicenseDataSource encapsula informações sobre o estado do produto chamado "ItalianRecipes". Esse produto é definido em license.xml.

  • Como adicionamos uma nova classe e precisamos referenciá-la no XAML, é preciso compilar o projeto. Para isto, selecione o menu Build / Rebuild Solution.
  • Abra o arquivo ItemDetailPage.xaml e adicione os seguintes códigos na seção <Page.Resources>.
<local:ProductLicenseDataSource x:Key="License" />
<common:BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>
  • Localize os dois controles TextBlocks cuja propriedade Text=“{Binding Directions}”. Altere cada TextBlock pelos códigos a seguir. Basicamente no primeiro TextBlock onde o Binding é para a propriedade Directions (Modo de preparo), há o controle dos atributos Visibility e o Converter para controlar se exibe ou não os dados. Já no botão é atribuído o evento OnPurchaseProduct ao atributo Click. Já o controle se o botão será ou não exibido, depende da propriedade IsTrial, juntamente com o Converter. Este botão contém um TextBlock onde o texto será o preço do produto, apontando o Binding para a propriedade FormattedPrice.
DE:

<TextBlock FontSize="20" FontWeight="Light" Text="{Binding Directions}" TextWrapping="Wrap" />

PARA:

<TextBlock FontSize="20" FontWeight="Light" 
           Text="{Binding Directions}" TextWrapping="Wrap" 
           Visibility="{Binding IsLicensed, Source={StaticResource License}, Converter={StaticResource BooleanToVisibilityConverter }}" />
<Button Width="225" Height="120" Background="#30ffffff" Click="OnPurchaseProduct" 
        Visibility="{Binding IsTrial, Source={StaticResource License}, Converter={StaticResource BooleanToVisibilityConverter }}">
    <Button.Content>
        <TextBlock Text="{Binding FormattedPrice, Source={StaticResource License}}" 
                   TextWrapping="Wrap" TextAlignment="Center" />
    </Button.Content>
</Button>
  • Pressione F7 para mostrar o código C#. Adicione o seguinte código na lista de using no topo do arquivo.
using Windows.ApplicationModel.Store;
  • Adicione os seguintes códigos no final do método LoadState. Este código irá capturar o título do grupo e passá-lo para o objeto license.
// Pass the group title to the LicenseDataSource (important!)
ProductLicenseDataSource license = (ProductLicenseDataSource)this.Resources["License"];
license.GroupTitle = item.Group.Title;
Dn175728.note(pt-br,MSDN.10).gifNota:
Este código é importante porque permite que ProductLicenseDataSource saber se a receita exibida no momento é uma receita italiana ou outra receita.

  • Agora é preciso criar o código do evento Click do botão de compras inserido anteriormente. Para isto, adicione os seguintes códigos para o método OnPurchaseProduct.
private void OnPurchaseProduct(object sender, RoutedEventArgs e)
{
    // Purchase the "ItalianRecipes" product
    CurrentAppSimulator.RequestProductPurchaseAsync("ItalianRecipes", false);
}

Tarefa 2 – Comprar um Produto

Tudo o que resta agora é testar as alterações e ver a compra do produto em ação.

  • Pressione F5 para exeuctar a aplicação.
  • Selecione qualquer receita do grupo Italian para exibir os detalhes da mesma. Note na Figura 8, que você visualiza todas os dados da receita, exceto o modo de preparo, pois este é pago.

Dn175728.8A3428292CD368596B360D4D10CFF143(pt-br,MSDN.10).png

Figura 8 – UI para comprar o produto

  • Clique no botão comprar para iniciar a compra do produto.
  • Será exibida a janela do Windows Store para simular a compra, conforme a Figura 9. Clique no botão Continuar para comprar o modo de preparo.

Dn175728.EB37605DFEC265CFFFAFF2DE64E27CD2(pt-br,MSDN.10).png

Figura 9 – Comprar o modo de preparo

  • Confirme que o botão desaparecerá e o modo de preparo será mostrado, conforme Figura 10.

Dn175728.54AF67A13DFA948F621D0879641DF9B3(pt-br,MSDN.10).png

Figura 9 – Todas as informações da receita

  • Navegue pelas outras receitas italianas e veja que o modo de preparo é exibido sem problemas.

Resumo

Os exercícios feitos neste laboratório demonstram alguns dos aspectos mais importantes da API do Windows Store, como detectar versões de teste, como simular a compra de um aplicativo, como simular a compra de produtos na aplicação, e como recuperar informações sobre os produtos. Claro, em um aplicativo real, você substituirá as chamadas de CurrentAppSimulator com chamadas para CurrentApp. Com isso, você terá todas as ferramentas necessárias para rentabilizar a seu aplicação. Vá em frente e gere receitas!

Sobre o Autor

Renato Haddad (rehaddad@msn.comwww.renatohaddad.com ) é MVP, MCT, MCPD e MCTS, palestrante em eventos da Microsoft em diversos países, ministra treinamentos focados em produtividade com o VS.NET 2010/2012, ASP.NET 4, ASP.NET MVC, Entity Framework, Reporting Services, Windows Phone e Windows 8. Visite o blog http://weblogs.asp.net/renatohaddad .

Mostrar:
© 2014 Microsoft