Criar layouts de loja personalizados

O Google Play gerenciado permite projetar e criar layouts de loja para clientes empresariais. Você pode personalizar o layout de uma loja agrupando apps em clusters, configurando páginas e adicionando links rápidos que fornecem acesso a várias páginas.

Todos os apps disponibilizados para um usuário final na loja do Google Play gerenciado precisam ser aprovados por um administrador de TI, aprovados para o usuário e adicionados a um cluster. Consulte Adicionar apps a um layout de loja para saber mais detalhes sobre esse processo.

Elementos do layout de uma loja

Um layout de loja geralmente consiste em uma série de páginas exibidas aos usuários no Google Play gerenciado. Cada página pode conter um ou mais grupos de apps, chamados de clusters. Cada cluster contém um ou mais apps.

Com os clusters, é possível agrupar apps relacionados. Por exemplo, é possível criar uma página para apps relacionados ao trabalho que contenha um cluster do Essentials e um cluster de Getting Done. O cluster do Essentials pode conter apps como o Notepad+, o Apresentações Google e assim por diante. O cluster de tarefas em andamento pode incluir apps como OneNote, Wunderlist, Any.do e outros apps de rastreamento, agenda e planejamento de reuniões (veja a Figura 1).

Ao criar uma página, você também pode adicionar até 10 links rápidos na parte superior dela. Os links rápidos permitem que os usuários acessem outras páginas. Por exemplo, a Figura 1 mostra links rápidos para as páginas Negócios, Comunicações e Finanças.

A Figura 1 mostra alguns dos principais elementos de um layout de loja, conforme visto em um dispositivo:

Um exemplo de tela de um dispositivo de usuário mostrando os elementos do layout de uma loja, incluindo links rápidos, páginas e clusters de apps.
Figura 1: exemplo de tela de um dispositivo de usuário
  • Links rápidos: links opcionais que dão acesso a outras páginas. Os links rápidos recebem o nome da página para a qual apontam.
  • Página: uma página nomeada, rolável na vertical que compreende clusters de apps.
  • Cluster (também chamado de coleção): um carrossel de apps nomeado e rolável na horizontal. Expande-se para a página inteira se a página contiver um único cluster ou clique em "Mais" para torná-la rolável verticalmente.

Limitações de elementos de layout da loja

Ao projetar e implementar layouts de loja para seus clientes, lembre-se destes limites. A maioria deles se deve a princípios de um bom design de interface:

  • 100 apps por cluster
  • 30 clusters por página
  • 10 links rápidos por página
  • 100 páginas por loja
  • 1.000 produtos (apps aprovados) por empresa

Nomes de páginas e clusters localizados

O layout da loja do Google Play gerenciado oferece suporte a nomes localizados para páginas e clusters de lojas. Ao criar uma página ou um cluster, você fornece uma lista de localidades compatíveis, como tags de idioma IETF e nomes localizados associados. Se a localidade de um usuário não estiver na lista com suporte, o sistema vai escolher a correspondência mais próxima disponível. Por exemplo, se en-GB não estiver disponível, o sistema escolherá en-US. Se nenhuma correspondência aproximada estiver disponível, o sistema escolherá o nome na lista.

Adicionar apps ao layout de uma loja

Todos os apps presentes em policy.productPolicy serão adicionados automaticamente se uma empresa estiver usando um layout de armazenamento básico. Se uma empresa estiver usando um layout de loja personalizado, os apps presentes apenas no layout personalizado e a lista de productPolicy serão exibidos em um dispositivo. Todos os itens presentes em policy.productPolicy podem ser pesquisáveis na Play Store.

Para que um usuário final instale um app da Google Play Store gerenciada, o app precisa ser compatível com o dispositivo do usuário e atender à seguinte condição:

  • Adicionado à lista de permissões do usuário (usando policy.productPolicy no recurso do dispositivo) E policy.productAvailabilityPolicy estiver definido como WHITELIST OU policy.productAvailabilityPolicy estiver definido como ALL, permitindo a pesquisa e a instalação de qualquer app.

Um usuário pode usar o recurso de pesquisa integrado ao Google Play gerenciado para encontrar e instalar qualquer app que atenda a essas condições. No entanto, o app só vai ficar visível em um layout de armazenamento básico ou se você tiver adicionado o app a uma coleção/cluster.

Apps com aprovação revogada

Os administradores podem não aprovar um app (revogar a aprovação dele) a qualquer momento. Os apps com aprovação revogada ainda podem ser adicionados a clusters e listas de permissões dos usuários, mas eles não vão aparecer para eles nem poderão instalá-los pela Google Play Store gerenciada. Se um app com aprovação revogada for aprovado, ele será disponibilizado para os usuários novamente na Google Play Store gerenciada.

Layout básico da loja

Por padrão, um layout de loja básico é ativado para cada um dos seus clientes. O layout básico tem uma página e um cluster, mostrando no máximo 1.000 apps. Os apps na página são classificados em ordem de valor de product ID. Se você criar um layout de loja personalizado (definindo storeLayoutType ="custom"), o layout de loja básico será desativado.

Criar layouts de loja personalizados

Os EMMs podem criar layouts de loja personalizados para cada cliente corporativo. Os layouts de armazenamento personalizados permitem configurar clusters de apps, adicionar clusters específicos a páginas e especificar links rápidos. Como você define os apps que compõem cada cluster, é possível usar clusters para agrupar apps relacionados (por exemplo, "Essentials" e "Como realizar tarefas"). Os usuários só veem os apps com permissões que foram aceitas pelo administrador de TI.

A referência da API Google Play EMM tem informações sobre os recursos e os métodos associados usados para criar um layout de armazenamento personalizado, mais especificamente, Storelayoutpages e Storelayoutclusters. As etapas descritas nas seções abaixo orientam você em um exemplo básico.

Tarefas de programação

Para criar um layout personalizado da loja do Google Play gerenciado para seus clientes, faça o seguinte:

  1. Criar uma página
  2. Criar um ou mais clusters dentro das páginas
  3. Definir a página inicial

No mínimo, você precisa criar pelo menos uma página que consiste em um cluster para um layout de armazenamento. Além disso, o cluster precisa conter pelo menos um app. Você também precisa definir a página inicial. Se você criar mais de uma página, terá a opção de definir links rápidos para exibição na parte superior de cada página.

As tarefas de programação para criar um layout personalizado da Play Store gerenciada são descritas abaixo, seguidas por um exemplo completo de um layout de loja.

Criar uma página

Uma página consiste em um ou mais clusters. Cada cluster contém pelo menos um app. Páginas são criadas para empresas específicas. Portanto, você precisa invocar operações em instâncias empresariais específicas (enterpriseId). É possível fornecer um nome e informações de localização fáceis de usar para cada página, com uma lista de pageIds que os usuários podem acessar na página. A nova página é criada com a operação insert (Storelayoutpages.insert), conforme mostrado aqui:

public StorePage createPage(String enterpriseId, String name)
    throws IOException {
  List<LocalizedText> names =
      ImmutableList.of(
          new LocalizedText().setLocale("en").setText(name));
  StorePage storePage = new StorePage();
  storePage.setName(names);
  return androidEnterprise.storelayoutpages()
    .insert(enterpriseId, storePage)
    .execute();
}

Criar um cluster

Os clusters contêm grupos de apps. O cluster é criado primeiro e depois pode ser adicionado a uma página. Para criar um cluster, invoque a operação insert de Storelayoutclusters e transmita os valores destas propriedades:

  • Uma lista dos productIds que o cluster precisa conter. Por exemplo, o productId do Gmail é app:com.google.android.gm.
  • Um nome fácil de usar para o cluster, como papéis Get Done Done
  • O enterpriseId que precisa ser associado ao cluster
  • O pageId (para a página que deve conter o cluster)
  • O posicionamento do cluster na página (primeiro, segundo e assim por diante)

Veja um exemplo:

private String insertCluster(String enterpriseId, String pageId, String name,
    List<String> productIds, String orderInPage) throws IOException {
  StoreCluster storeCluster = new StoreCluster();
  storeCluster.setName(
      ImmutableList.of(
          new LocalizedText().setLocale("en").setText(name)));
  storeCluster.setProductId(productIds);
  storeCluster.setOrderInPage(orderInPage);
  return androidEnterprise.storelayoutclusters()
    .insert(enterpriseId, pageId, storeCluster)
    .execute()
    .getId();
}

Definir a página inicial

A primeira página exibida no Google Play gerenciado no dispositivo de um usuário é a página inicial. Como EMM, você define uma página inicial para cada um dos seus clientes. A página está sempre visível, mesmo quando está vazia, e não pode ser excluída.

Neste exemplo, o ID da página inicial é buscado para o enterpriseId especificado:

public StoreLayout getStoreLayout(String enterpriseId) throws IOException {
  return androidEnterprise
    .enterprises()
    .getStoreLayout(enterpriseId)
    .execute();
}

O próximo exemplo define a página inicial de um cliente fornecendo o enterpriseId e o pageId da página inicial dele:

public StoreLayout setStoreLayout(String enterpriseId, String homepageId)
    throws IOException {
  StoreLayout storeLayout = new StoreLayout();
  storeLayout.setHomepageId(homepageId);

  return androidEnterprise
    .enterprises()
    .setStoreLayout(enterpriseId, storeLayout)
    .execute();
}

Links rápidos são exibidos na parte superior de cada página, permitindo que os usuários naveguem facilmente entre as páginas da loja. Para usar links rápidos, primeiro acesse o pageId da página (retornado por insert) e adicione o link à página. Por exemplo, se você criar três páginas com pageIds como p1, p2 e p3, será possível adicionar links rápidos da primeira página para as outras duas com o seguinte:

StorePage storePage = new StorePage();
storePage.setName(
    ImmutableList.of(new LocalizedText().setLocale("en").setText(title)));
storePage.setLink(ImmutableList.of("p2", "p3");
return androidEnterprise.storelayoutpages()
  .update(enterpriseId, "p1", storePage)
  .execute();

Exemplo

Veja um exemplo completo que cria um armazenamento básico que consiste em três páginas interligadas. Cada página é formada por clusters de aplicativos semelhantes. Cada página é criada especificando o enterpriseId do cliente e definindo apenas o name da página para receber o pageId, que é usado para criar um link rápido para a página.

// Create a basic page and return the pageId.
private String insertPage(String enterpriseId, String title,
    List<String> links) throws IOException {
  List<LocalizedText> names =
      ImmutableList.of(new LocalizedText().setLocale("en").setText(title));
  StorePage page = new StorePage();
  page.setName(names);
  page.setLink(links);
  return enterprise.storelayoutpages().insert(enterpriseId, page).execute().getId();
}

public StoreLayout setStoreLayout(String enterpriseId, String homepageId)
    throws IOException {
  StoreLayout storeLayout = new StoreLayout();
  storeLayout.setHomepageId(homepageId);

  return androidEnterprise
      .enterprises()
      .setStoreLayout(enterpriseId, storeLayout)
      .execute();
}

private String insertCluster(String enterpriseId, String pageId, String name,
    List<String> productIds, String orderInPage) throws IOException {
  StoreCluster cluster = new StoreCluster();
  List<LocalizedText> names =
      ImmutableList.of(new LocalizedText().setLocale("en").setText(name));
  cluster.setName(names);
  cluster.setProductId(productIds);
  cluster.setOrderInPage(orderInPage);
  return androidEnterprise.storelayoutclusters()
      .insert(enterpriseId, pageId, cluster)
      .execute()
      .getId();
}

private void updatePage(String enterpriseId, String pageId, String title,
    List<String> links) throws IOException {
  List<LocalizedText> names =
      ImmutableList.of(new LocalizedText().setLocale("en").setText(title));
  StorePage page = new StorePage();
  page.setName(names);
  page.setLink(links);
  enterprise.storelayoutpages()
      .update(enterpriseId, pageId, page).execute();
}

private void makeStore(String enterpriseId) throws IOException {
  // Create the pages.
  String page1 = insertPage(enterpriseId, "Home");
  String page2 = insertPage(enterpriseId, "Productivity");
  String page3 = insertPage(enterpriseId, "Accounting");

  // Set the homepage (page that displays by default when store is opened).
  setStoreLayout(enterpriseId, page1);

  // Add the links to the pages. This makes a small tree.
  updatePage(enterpriseId, page1, "Home", ImmutableList.of(page2, page3));
  updatePage(enterpriseId, page2, "Productivity", ImmutableList.of(page1));
  updatePage(enterpriseId, page3, "Accounting", ImmutableList.of(page1));

  // Add clusters with contents.
  insertCluster(
      enterpriseId,
      page1,
      "Getting Things Done",
      ImmutableList.of(
          "app:com.mytodolist",
          "app:com.google.android.gm",
          "app:com.google.android.docs"),
      "1");
  insertCluster(
      enterpriseId,
      page1,
      "Strategy",
      ImmutableList.of(
          "app:com.myplanner",
          "app:com.stratego"),
      "2");
  insertCluster(
      enterpriseId,
      page2,
      "Editors",
      ImmutableList.of(
          "app:com.myeditor",
          "app:com.betteredit",
          "app:com.lazyguy"),
      "1");
  insertCluster(
      enterpriseId,
      page2,
      "Time Management",
      ImmutableList.of(
          "app:com.mytimetracker",
          "app:com.lazygal",
          "app:com.lazyguy"),
      "2");
  insertCluster(
      enterpriseId,
      page2,
      "Accounting",
      ImmutableList.of(
          "app:com.mymoney",
          "app:com.taxpro",
          "app:com.balances"),
      "3");
}