Tworzenie niestandardowych układów sklepów

Zarządzany Sklep Google Play umożliwia projektowanie i tworzenie układów sklepów dla Twojej firmy klientów. Możesz dostosować układ sklepu, grupując aplikacje w klastry, skonfigurować strony w sklepie i dodać szybkie linki, które dają dostęp do w sklepie.

Wszystkie aplikacje udostępnione użytkownikom w zarządzanym Sklepie Google Play. musi zostać najpierw zatwierdzony przez administratora IT, zatwierdzony dla użytkownika i dodany do i konkretnie do klastra. Więcej informacji znajdziesz w artykule Dodawanie aplikacji do układu sklepu. ).

Elementy układu sklepu

Układ sklepu składa się zwykle z serii stron wyświetlanych użytkownikom zarządzanego Sklepu Google Play. Każda strona może zawierać jedną lub więcej grup aplikacji, jako klastry. Każdy klaster zawiera co najmniej 1 aplikację.

Klastry umożliwiają grupowanie powiązanych aplikacji. Możesz na przykład utworzyć stronę aplikacje związane z pracą, które zawierają klaster Essentialsi klaster Get Things Gotowe. Klaster Essentials może zawierać takie aplikacje jak Notatnik+, Prezentacje Google itd. Klaster „Get Things Done” może zawierać aplikacje takich jak OneNote, Wunderlist, Any.do i inne narzędzia do śledzenia, aplikacje do planowania spotkań (zobacz ilustrację 1).

Podczas tworzenia strony możesz też dodać maksymalnie 10 szybkich linków na górze strony. stronę. Szybkie linki umożliwiają użytkownikom przechodzenie na inne strony. Na przykład na ilustracji 1 widać, szybkie linki do stron Biznes, Komunikacja i Finanse.

Ilustracja 1 przedstawia wybrane kluczowe elementy układu sklepu na urządzeniach:

Przykładowy ekran urządzenia użytkownika przedstawiający elementy sklepu układem obejmujący szybkie linki, strony i klastry aplikacji.
Rysunek 1. Przykładowy ekran na urządzeniu użytkownika
  • Szybkie linki: opcjonalne linki dające dostęp do innych stron. Szybki przyjmują nazwę strony, do której prowadzą.
  • Strona: nazwana, przewijana w pionie strona zawierająca klastry aplikacji.
  • Klaster (inaczej kolekcja): nazwana, przewijana w poziomie. karuzela aplikacji. Rozwija do pełnej strony, jeśli strona zawiera pojedynczy klaster (lub kliknij „Więcej”. aby umożliwić przewijanie w pionie).

Ograniczenia elementów układu sklepu

Podczas projektowania i wdrażania układów w sklepie dla klientów pamiętaj o tych kwestiach: :

  • 100 aplikacji na klaster
  • 30 klastrów na stronie
  • 10 szybkich linków na stronie
  • 100 stron na sklep
  • 1000 produktów (zatwierdzonych aplikacji) na firmę

Zlokalizowane nazwy stron i klastrów

Układ zarządzanego Sklepu Google Play obsługuje zlokalizowane nazwy stron sklepów i przechowywania klastrów. Podczas tworzenia strony lub klastra podajesz listę obsługiwane języki, tagi języka IETF i powiązane zlokalizowane nazwy. Jeśli języka użytkownika nie ma na liście obsługiwanych, system wybiera najbliższy dopasowania. Jeśli na przykład nie jest dostępna wartość en-US, system wybiera en-US . Jeśli brak bliskiego odpowiednika, system wybiera imię listę.

Dodawanie aplikacji do układu sklepu

Wszystkie aplikacje w aplikacji policy.productPolicy są dodawane automatycznie, jeśli firmy używa podstawowego układu sklepu. Jeśli firma używa niestandardowego atrybutu układ sklepu, aplikacje dostępne tylko w układzie niestandardowym i na liście productPolicy będzie wyświetlana na urządzeniu. Wszystkie elementy w folderze policy.productPolicy są które można znaleźć w Sklepie Play.

Użytkownik może zainstalować aplikację z zarządzanego Sklepu Google Play, musi być zgodny z urządzeniem użytkownika i spełniać ten warunek:

  • Dodano do listy dozwolonych użytkownika (za pomocą policy.productPolicy na urządzeniu zasób) ORAZ policy.productAvailabilityPolicy ma wartość WHITELIST, LUB policy.productAvailabilityPolicy ma wartość ALL (zezwala na wyszukiwanie i instalacji dowolnej aplikacji).

Użytkownik może używać funkcji wyszukiwania wbudowanej w zarządzany Sklep Google Play, by znajdować zainstalować dowolną aplikację, która spełnia te warunki. Jednak aplikacja będzie dostępna tylko widoczna w podstawowym układzie sklepu lub jeśli aplikacja została dodana do zbiór/klaster.

Aplikacje, których zatwierdzenie zostało anulowane

Administratorzy mogą w każdej chwili cofnąć zatwierdzenie aplikacji. Aplikacje z unieważnione zatwierdzenie wciąż można dodawać do klastrów i użytkowników listy dozwolonych, ale użytkownicy nie zobaczą ich i nie będą mogli ich instalować z poziomu zarządzanego konta Google, Sklep Play. Jeśli aplikacja z cofniętym zatwierdzeniem zostanie ponownie zatwierdzona, zostanie ona ponownie zatwierdzona są ponownie dostępne dla użytkowników w zarządzanym Sklepie Google Play.

Podstawowy układ sklepu

Domyślnie dla każdego z Twoich klientów włączony jest podstawowy układ sklepu. układ podstawowy obejmuje 1 stronę i 1 klaster, w których wyświetla się maksymalnie 1000 aplikacji. Aplikacje włączone strony są posortowane w kolejności według wartości product ID. Jeśli utworzysz niestandardowe układ sklepu (przy ustawieniu storeLayoutType ="custom"), podstawowy układ sklepu to wyłączono.

Tworzenie niestandardowych układów sklepu

Dostawcy usług EMM mogą tworzyć niestandardowe układy sklepów dla każdego z klientów korporacyjnych. Niestandardowe układy sklepów pozwalają konfigurować klastry aplikacji oraz dodawać określone klastry stron i określić szybkie linki. Ponieważ to Ty określasz aplikacje składające się na możesz używać klastrów do grupowania powiązanych aplikacji (np. „Essentials”). i „Jak załatwiać sprawy”). Użytkownicy widzą tylko te aplikacje, których uprawnienia została zaakceptowana przez administratora IT.

W dokumentacji interfejsu Google Play EMM API znajdziesz informacje o zasobach i powiązane metody tworzenia niestandardowego układu sklepu, Storelayoutpages i Storelayoutclusters; Aby to zrobić, wykonaj czynności opisane w poniżej przedstawiono podstawowy przykład.

Zadania programowania

Aby utworzyć niestandardowy układ zarządzanego Sklepu Google Play dla klientów: musi:

  1. Utwórz stronę
  2. Utwórz co najmniej 1 klaster na stronach
  3. Ustawianie strony głównej

Musisz utworzyć co najmniej jedną stronę składającą się z jednego klastra na potrzeby a klaster musi zawierać co najmniej 1 aplikację. Musisz także ustawić stronie głównej. Jeśli tworzysz więcej niż jedną stronę, możesz szybko które wyświetlają się u góry każdej strony.

Zadania programowania potrzebne do utworzenia niestandardowego układu zarządzanego Sklepu Play to: poniżej znajdziesz pełny przykład układu sklepu.

Utwórz stronę

Strona składa się z co najmniej 1 klastra. Każdy klaster zawiera co najmniej 1 aplikację. Strony są tworzone dla konkretnych firm, więc należy wywołać operacje na dla określonych instancji firmowych (enterpriseId). Możesz podać adres URL przyjazny dla użytkownika nazwa i informacje o lokalizacji każdej strony oraz lista stron (pageId) do których użytkownicy mogą dotrzeć na stronie. Nowa strona jest tworzona za pomocą tagu insert (Storelayoutpages.insert) tak jak tutaj:

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

Utwórz klaster

Klastry zawierają grupy aplikacji. Klaster zostanie utworzony najpierw, a następnie będzie mógł dodać do strony. Aby utworzyć klaster, wywołaj operację insert Storelayoutclusters i przekazywanie wartości dla tych właściwości:

  • Lista obiektów productId, które powinien zawierać klaster (na przykład productId w Gmailu jest app:com.google.android.gm)
  • Przyjazna dla użytkownika nazwa klastra, na przykład Udzielanie informacji o rzeczach. Gotowe
  • Obiekt enterpriseId, który powinien być powiązany z klastrem
  • pageId (strona, która powinna zawierać klaster)
  • Położenie klastra na stronie (pierwsza, druga itd.)

Oto przykład:

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

Ustawianie strony głównej

Pierwsza strona wyświetlana w zarządzanym Sklepie Google Play na urządzeniu użytkownika to stronie głównej. Jako dostawca usług EMM określasz stronę główną dla każdego z klientów. jest zawsze widoczna, nawet gdy jest pusta, i nie można jej usunąć.

W tym przykładzie pobierany jest identyfikator strony głównej dla określonego enterpriseId:

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

Następny przykład określa stronę główną klienta, podając klienta enterpriseId i pageId tego klienta strona główna:

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

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

Szybkie linki są wyświetlane u góry każdej strony, umożliwiając użytkownikom łatwe poruszanie się między stronami w sklepie. Aby korzystać z szybkich linków, najpierw uzyskaj pageId dla (zwrócone przez: insert) i dodaj do niej link. Jeśli na przykład utwórz trzy strony, których pageId to p1, p2, p3, możesz dodać szybkie linki między pierwszą a dwiema pozostałymi stronami:

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();

Przykład

Oto pełny przykład tworzenia podstawowego sklepu, który składa się z 3 elementów między linkami. Na każdej stronie znajdują się grupy podobnych aplikacji. Każda strona jest utworzone przez określenie enterpriseId klienta i ustawienie strony name aby uzyskać jego pageId, który następnie zostanie użyty do utworzenia szybkiego linku do stronę.

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