Tworzenie niestandardowych układów sklepów

Uwaga: nowa integracja nie powinna tworzyć niestandardowych układów sklepów, ale powinna integrować element iframe z zarządzanego Sklepu Google Play. Umieszczenie zarządzanego Sklepu Google Play bezpośrednio w konsoli EMM zapewnia klientom ujednolicone zarządzanie urządzeniami mobilnymi.

Zarządzany Sklep Google Play pozwala projektować i tworzyć układy sklepów przeznaczone dla klientów firmowych. Układ sklepu można dostosować, grupując aplikacje w klastry, konfigurując strony sklepów i dodając szybkie linki dające dostęp do wielu stron w sklepie.

Wszystkie aplikacje udostępniane użytkownikowi w zarządzanym Sklepie Google Play muszą najpierw zostać zatwierdzone przez administratora IT, zatwierdzone dla użytkownika i dodane do klastra. Więcej informacji o tym procesie znajdziesz w artykule Dodawanie aplikacji do układu sklepu.

Elementy układu sklepu

Układ sklepu zazwyczaj składa się z serii stron wyświetlanych użytkownikom w zarządzanym Sklepie Google Play. Każda strona może zawierać 1 lub więcej grup aplikacji – tzw. klastry. Każdy klaster zawiera co najmniej 1 aplikację.

Klastry umożliwiają grupowanie powiązanych aplikacji. Możesz na przykład utworzyć stronę aplikacji związanych z pracą, która zawiera klaster Essentials i klaster Załatwianie spraw. Klaster Essentials może zawierać takie aplikacje jak Notatnik+ czy Prezentacje Google. Klaster Do zrobienia może zawierać aplikacje takie jak OneNote, Wunderlist czy Any.do oraz inne aplikacje do śledzenia, kalendarza i planowania spotkań (patrz Rysunek 1).

Podczas tworzenia strony możesz też dodać maksymalnie 10 szybkich linków u góry strony. Szybkie linki pozwalają użytkownikom przechodzić na inne strony. Na przykład na rysunku 1 widać szybkie linki do stron Biznes, Komunikacja i Finanse.

Rysunek 1 przedstawia najważniejsze elementy układu sklepu w widoku urządzenia:

Rysunek 1. Przykładowy ekran urządzenia użytkownika

• Szybkie linki: opcjonalne linki umożliwiające dostęp do innych stron. Szybkie linki przyjmują nazwę strony, do której prowadzą.
• Strona: nazwana strona, którą można przewijać w pionie, złożona z grup aplikacji.
• Klaster (nazywany też kolekcją): nazwana karuzela aplikacji, którą można przewijać w poziomie. Rozwija się do pełnej strony, jeśli strona zawiera 1 klaster (lub kliknij „Więcej”, aby można było przewijać w pionie).

Ograniczenia elementów układu sklepu

Podczas projektowania i implementowania układów sklepów dla klientów pamiętaj o tych ograniczeniach (większość z nich wynika z dobrego projektu interfejsu):

• 100 aplikacji na klaster
• 30 klastrów na stronę
• 10 szybkich linków na stronie.
• 100 stron na sklep
• 1000 usług (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 klastrów sklepów. Podczas tworzenia strony lub klastra podajesz listę obsługiwanych lokalizacji, np. tagi języka IETF, i powiązane z nimi zlokalizowane nazwy. Jeśli języka użytkownika nie ma na liście obsługiwanych, system wybiera najbliższe dostępne dopasowanie. Jeśli np. opcja en-GB jest niedostępna, system wybiera zamiast niej język en-US. Jeśli nie ma dopasowania, system wybiera imię na liście.

Dodawanie aplikacji do układu sklepu

Wszystkie aplikacje dostępne w policy.productPolicy są dodawane automatycznie, jeśli organizacja używa podstawowego układu sklepu. Jeśli firma używa niestandardowego układu sklepu, na urządzeniu będą wyświetlane tylko aplikacje występujące w układzie niestandardowym i na liście productPolicy. Wszystkie produkty z kategorii policy.productPolicy można wyszukać w Sklepie Play.

Aby użytkownik mógł zainstalować aplikację z zarządzanego Sklepu Google Play, musi ona być zgodna z jego urządzeniem i spełniać ten warunek:

• Dodano do listy dozwolonych użytkownika (za pomocą policy.productPolicy w zasobie urządzenia), a policy.productAvailabilityPolicy ma wartość WHITELIST lub policy.productAvailabilityPolicy ma wartość ALL (umożliwia wyszukiwanie i instalowanie dowolnej aplikacji).

Użytkownik może użyć funkcji wyszukiwania wbudowanej w zarządzany Sklep Google Play, aby znaleźć i zainstalować dowolną aplikację, która spełnia te warunki. Aplikacja będzie jednak widoczna tylko w podstawowym układzie sklepu lub wtedy, gdy została dodana do kolekcji/klastra.

Uwaga: jeśli użytkownik ma już zatwierdzoną aplikację, która należy do klastra, będzie można ją wyszukać w zarządzanym Sklepie Google Play, ale nie będzie widoczna jako część klastra, chyba że będzie na liście dozwolonych użytkownika.

Aplikacje z cofniętą zgodą

Administratorzy mogą w każdej chwili cofnąć zatwierdzenie aplikacji (cofnięcie jej zatwierdzenia). Aplikacje, których zatwierdzenie zostało cofnięte, nadal można dodawać do klastrów i list dozwolonych użytkowników, ale użytkownicy nie będą ich widzieć ani mieć możliwości instalowania ich z zarządzanego Sklepu Google Play. Jeśli aplikacja, której zatwierdzenie została cofnięta, zostanie ponownie zatwierdzona, zostanie ona ponownie udostępniona użytkownikom w zarządzanym Sklepie Google Play.

Podstawowy układ sklepu

Domyślnie każdy klient ma włączony podstawowy układ sklepu. Podstawowy układ zawiera 1 stronę i 1 klaster z maksymalnie 1000 aplikacji. Aplikacje na stronie są posortowane według wartości product ID. Jeśli utworzysz niestandardowy układ sklepu (za pomocą ustawienia storeLayoutType ="custom"), podstawowy układ sklepu będzie wyłączony.

Tworzenie niestandardowych układów sklepów

Dostawcy usług EMM mogą tworzyć niestandardowe układy sklepów dla poszczególnych klientów firmowych. Niestandardowe układy sklepów pozwalają konfigurować klastry aplikacji, dodawać określone klastry do stron i określać szybkie linki. Ponieważ określasz aplikacje wchodzące w skład każdego klastra, możesz używać klastrów do grupowania powiązanych aplikacji (np. „Essentials” i „Załatwianie spraw”). Użytkownicy widzą tylko te aplikacje, których uprawnienia zostały zaakceptowane przez administratora IT.

Dokumentacja interfejsu Google Play EMM API zawiera informacje o zasobach i powiązanych metodach tworzenia niestandardowego układu sklepu, takich jak Storelayoutpages i Storelayoutclusters. Kroki opisane w poniższych sekcjach obejmują podstawowy przykład.

Zadania programistyczne

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

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

Musisz utworzyć co najmniej 1 stronę składającą się z 1 klastra dla układu sklepu, a klaster musi zawierać co najmniej 1 aplikację. Musisz też ustawić stronę główną. Jeśli utworzysz więcej niż jedną stronę, możesz ustawić szybkie linki, które będą się wyświetlać u góry każdej z nich.

Zadania programistyczne związane z tworzeniem niestandardowego układu zarządzanego Sklepu Play zostały opisane poniżej. Poniżej znajduje się kompletny 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, musisz więc wywoływać operacje na konkretnych instancjach firmowych (enterpriseId). Możesz podać przyjazną nazwę i informacje o lokalizacji każdej strony, a także listę elementów pageId, do których użytkownicy mogą uzyskiwać dostęp z poziomu strony. Nowa strona została utworzona za pomocą operacji insert (Storelayoutpages.insert) w ten sposób:

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

Uwaga: jeśli utworzysz więcej niż 1 stronę, możesz korzystać z szybkich linków, aby mieć do nich szybki dostęp. Jeśli utworzysz więcej niż jedną stronę, dodaj linki do wszystkich stron, ponieważ bez linku do niej nie będzie można uzyskać dostępu. Inaczej mówiąc, zarządzany Sklep Play nie blokuje tworzenia osieroconych stron.

Tworzenie klastra

Ważne: możesz też ułatwić tworzenie klastrów, umieszczając element iframe zarządzanego Sklepu Google Play w konsoli.

Klastry zawierają grupy aplikacji. Klaster jest najpierw tworzony, a potem można go dodać do strony. Aby utworzyć klaster, wywołaj operację insert Storelayoutclusters i przekaż wartości dla tych właściwości:

• Lista productId, które powinien zawierać klaster (np. productId w przypadku Gmaila to app:com.google.android.gm).
• Przyjazna w użyciu nazwa klastra, np. piacjonarna realizacja.
• Element enterpriseId, który powinien być powiązany z klastrem
• Element pageId (dotyczy strony, 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 strona główna. Jako dostawca usług EMM możesz określić stronę główną dla każdego klienta. Strona jest zawsze widoczna, nawet gdy jest pusta. Nie można jej usunąć.

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

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

W kolejnym przykładzie pokazujemy stronę główną klienta, podając jego enterpriseId i pageId jego strony głównej:

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

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

Ustaw szybkie linki (opcjonalnie)

Uwaga: utworzenie klastrów (nazywanych też kolekcjami) w Kreatorze sklepów spowoduje usunięcie wszystkich istniejących szybkich linków. Aby je przywrócić, wywołaj metodę StoreLayoutPages.Update.

Szybkie linki są wyświetlane u góry każdej strony, co umożliwia użytkownikom łatwe poruszanie się między stronami sklepu. Aby korzystać z szybkich linków, najpierw uzyskaj pageId strony (zwróconej przez insert) i dodaj do niej link. Jeśli np. utworzysz 3 strony, których pageId to p1, p2, p3, możesz dodać szybkie linki z pierwszej strony do pozostałych:

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 kompletny przykład tworzenia podstawowego sklepu składającego się z 3 stron połączonych z internetem. Na każdej stronie składają się grupy podobnych aplikacji. Każda strona jest tworzona przez określenie enterpriseId klienta i ustawienie tylko strony name w celu uzyskania parametru pageId, który służy później do utworzenia szybkiego linku do strony.

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