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.](https://developers-dot-devsite-v2-prod.appspot.com/static/android/work/play/emm-api/store_layout_figure_1.png?authuser=9&hl=pl)
- 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) ORAZpolicy.productAvailabilityPolicy
ma wartośćWHITELIST
, LUBpolicy.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:
- Utwórz stronę
- Utwórz co najmniej 1 klaster na stronach
- 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ładproductId
w Gmailu jestapp: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();
}
Ustaw szybkie linki (opcjonalnie)
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");
}