Windows App - Windows Store

Por Renato Haddad

Maio, 2013

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.

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

• 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>https://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.

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

Figura 2 – Classe de gerenciamento da licença

• 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="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="using:ContosoCookbook"
        xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="https://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>

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

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>https://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.

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.

• 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);
    }

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.

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.

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.

Figura 7 – Compra efetuada

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";
                }
            }
        }
    }

• 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;

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

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.

Figura 9 – Comprar o modo de preparo

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

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.com – www.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 https://weblogs.asp.net/renatohaddad .

| Home | Artigos Técnicos | Comunidade