Ustawianie konfiguracji zarządzanych

Jeśli tworzysz aplikacje na rynek korporacyjny, być może trzeba będzie w celu spełnienia określonych wymagań określonych w zasadach organizacji. Konfiguracje zarządzane (znane wcześniej jako ograniczenia aplikacji), zezwól administratorowi IT organizacji na zdalne określanie ustawień aplikacji. Ta funkcja jest szczególnie przydatna w przypadku organizacji zatwierdzonych aplikacji wdrożonych w profilu służbowym.

Na przykład organizacja może wymagać, aby zatwierdzone aplikacje zezwalały na Administrator IT do:

• Zezwalanie na adresy URL w przeglądarce i blokowanie ich
• Określ, czy aplikacja może synchronizować treści przez sieć komórkową czy tylko przez Wi-Fi
• Konfigurowanie ustawień poczty e-mail w aplikacji

Z tego przewodnika dowiesz się, jak wdrożyć ustawienia konfiguracji zarządzanej w do aplikacji. Przykładowe aplikacje z konfiguracją zarządzaną znajdziesz na stronie ManagedConfigurations (Konfiguracje zarządzane). Jeśli jesteś deweloperem usług zarządzania urządzeniami mobilnymi (EMM), zapoznaj się z przewodnikiem po interfejsie Android Management API.

Uwaga: ze względów historycznych te ustawienia konfiguracji są nazywane są zaimplementowane za pomocą plików i klas,które korzystają z tego ograniczenia. (np. RestrictionsManager). Jednak te pozwalają implementować szeroką gamę opcji konfiguracji, nie tylko ograniczenia funkcji aplikacji.

Omówienie konfiguracji zdalnej

Aplikacje definiują opcje konfiguracji zarządzanej, które można zdalnie ustawione przez administratora IT. Są to dowolne ustawienia, których zmienione przez dostawcę konfiguracji zarządzanej. Jeśli aplikacja działa w profilu służbowym, administrator IT może zmienić konfigurację zarządzaną aplikacji.

Dostawca konfiguracji zarządzanych to inna aplikacja uruchomiona na tym samym urządzeniu. Tą aplikacją zwykle zarządza administrator IT. administrator IT przekazuje zmiany w konfiguracji do zarządzanego aplikacji dostawcy konfiguracji. Aplikacja z kolei zmieni konfigurację.

Aby udostępnić konfiguracje zarządzane zewnętrznie:

• Zadeklaruj konfiguracje zarządzane w manifeście aplikacji. Wykonuję więc administrator IT może odczytać za pomocą interfejsów Google Play API.
• Przy każdym wznowieniu aplikacji użyj obiektu RestrictionsManager, aby sprawdzić bieżącą konfiguracjach zarządzanych oraz zmienić UI i działanie aplikacji na zgodne z tymi konfiguracjami.
• Posłuchaj: Intencja ACTION_APPLICATION_RESTRICTIONS_CHANGED. Po otrzymaniu prześlij wiadomość, sprawdź RestrictionsManager, aby zobaczyć co i wprowadź niezbędne zmiany w zachowanie aplikacji.

Definiowanie konfiguracji zarządzanych

Aplikacja może obsługiwać dowolną konfigurację zarządzaną, którą chcesz zdefiniować. Deklarujesz zarządzanych konfiguracji aplikacji w pliku konfiguracji zarządzanych i zadeklarować pliku konfiguracji w pliku manifestu. Utworzenie pliku konfiguracji umożliwia do przeanalizowania konfiguracji zarządzanych udostępnianych przez Twoją aplikację. Partnerzy EMM może odczytywać konfiguracje aplikacji przy użyciu interfejsów API Google Play.

Aby określić opcje zdalnej konfiguracji aplikacji, umieść następujący element w pliku manifestu Element <application>:

<meta-data android:name="android.content.APP_RESTRICTIONS"
    android:resource="@xml/app_restrictions" />

Utwórz plik o nazwie app_restrictions.xml w folderze aplikacji res/xml. Struktura tego pliku jest opisana tutaj: plik referencyjny RestrictionsManager. Plik zawiera pojedynczy element <restrictions> najwyższego poziomu, który zawiera po 1 elemencie podrzędnym <restriction> dla każdej konfiguracji z dostępnych dla aplikacji opcji.

Uwaga: nie twórz zlokalizowanych wersji interfejsu pliku konfiguracji zarządzanej. Aplikacja może mieć tylko jeden plik konfiguracji zarządzanej, dlatego konfiguracje będą spójne dla aplikacji we wszystkich regionach.

W środowisku firmowym dostawca usług EMM zwykle używa zarządzanych schemat konfiguracji do generowania konsoli zdalnej dla działu IT administratorzy będą mogli zdalnie konfigurować aplikacji.

Dostawca konfiguracji zarządzanej może wysyłać zapytania do aplikacji, aby znaleźć szczegóły na temat dostępnych konfiguracji aplikacji, w tym ich opisu tekstu. Dostawca konfiguracji i administrator IT może zmienić ustawienia konfiguracje zarządzane w każdej chwili, nawet wtedy, gdy aplikacja nie jest uruchomiona.

Załóżmy na przykład, że aplikację można zdalnie skonfigurować w taki sposób, aby zezwalać na dostęp lub go blokować. , by pobierać dane przez sieć komórkową. Aplikacja może mieć <restriction> element podobny do tego:

<?xml version="1.0" encoding="utf-8"?>
<restrictions xmlns:android="http://schemas.android.com/apk/res/android">

  <restriction
    android:key="downloadOnCellular"
    android:title="@string/download_on_cell_title"
    android:restrictionType="bool"
    android:description="@string/download_on_cell_description"
    android:defaultValue="true" />

</restrictions>

Atrybutu android:key każdej konfiguracji używasz do: odczytuje jego wartość z pakietu konfiguracji zarządzanej. Z tego powodu każda konfiguracja musi mieć unikalny ciąg klucza, a ciąg nie można zlokalizować. Musi być określona za pomocą literału ciągu.

Uwaga: w produkcyjnej aplikacji funkcje android:title oraz android:description należy pobrać ze zlokalizowanego zasobu zgodnie z opisem w Lokalizacja przy użyciu zasobów.

Aplikacja definiuje ograniczenia za pomocą pakietów w obrębie bundle_array. Na przykład aplikacja z wieloma opcjami połączeń VPN może zdefiniować każdy serwer VPN. konfiguracja w: bundle z wieloma pakiety w tablicy pakietów:

<?xml version="1.0" encoding="utf-8"?>
<restrictions xmlns:android="http://schemas.android.com/apk/res/android" >

  <restriction
    android:key="vpn_configuration_list"
    android:restrictionType="bundle_array">
    <restriction
      android:key="vpn_configuration"
      android:restrictionType="bundle">
      <restriction
        android:key="vpn_server"
        android:restrictionType="string"/>
      <restriction
        android:key="vpn_username"
        android:restrictionType="string"/>
      <restriction
        android:key="vpn_password"
        android:restrictionType="string"/>
    </restriction>
  </restriction>

</restrictions>

Obsługiwane typy elementu android:restrictionType zostały wymienione w tabeli 1 i udokumentowane w referencyjnym dla RestrictionsManager i RestrictionEntry.

Tabela 1. Typy wpisów ograniczeń i ich wykorzystanie.

Uwaga: android:entryValues są czytelne dla komputera, więc nie i zlokalizowanego. Użyj android:entries, aby przedstawić zrozumiałe dla człowieka wartości, które można zlokalizować. Każdy wpis musi mieć odpowiedni indeks w polu android:entryValues.

Sprawdzanie konfiguracji zarządzanych

Aplikacja nie jest automatycznie powiadamiana, gdy inne aplikacje zmienią jej ustawienia konfiguracji. Zamiast tego musisz sprawdzić, co zarządza konfiguracji to moment uruchomienia lub wznawiania aplikacji i nasłuchiwać intencja systemu, by sprawdzić, czy konfiguracje zmieniają się jest uruchomiona aplikacja.

Aby poznać bieżące ustawienia konfiguracji, aplikacja używa RestrictionsManager obiekt. Aplikacja powinna sprawdź bieżące konfiguracje zarządzane w tych godzinach:

• Przy uruchomieniu lub wznowieniu działania aplikacji onResume() metoda
• Gdy aplikacja zostanie powiadomiona o zmianie konfiguracji, tak jak to opisano w sekcji Nasłuchuj konfiguracji zarządzanej Zmiany

Aby uzyskać obiekt RestrictionsManager, pobierz bieżącą aktywność z użytkownikiem getActivity(), a potem wywołaj metodę Activity.getSystemService() tej aktywności:

var myRestrictionsMgr =
        activity?.getSystemService(Context.RESTRICTIONS_SERVICE) as RestrictionsManager

RestrictionsManager myRestrictionsMgr =
    (RestrictionsManager) getActivity()
        .getSystemService(Context.RESTRICTIONS_SERVICE);

Gdy już będziesz mieć RestrictionsManager, możesz uzyskać dostęp do bieżących ustawień konfiguracji przez wywołanie Metoda getApplicationRestrictions():

var appRestrictions: Bundle = myRestrictionsMgr.applicationRestrictions

Bundle appRestrictions = myRestrictionsMgr.getApplicationRestrictions();

Uwaga: dla wygody możesz też pobrać aktualną konfiguracji z parametrem UserManager, wywołując UserManager.getApplicationRestrictions() Ta metoda działa dokładnie taka sama jak RestrictionsManager.getApplicationRestrictions().

Metoda getApplicationRestrictions() wymaga odczytu z magazynu danych, więc robić to z umiarem. Nie wywołuj tej metody za każdym razem, gdy chcesz aby poznać bieżącą konfigurację. Wywołuj je raz, gdy aplikacja uruchamia lub wznawia działanie oraz zapisuje w pamięci podręcznej pobrany pakiet konfiguracji zarządzanych. Potem słuchaj dla intencji ACTION_APPLICATION_RESTRICTIONS_CHANGED, by sprawdzić, czy konfiguracja zmienia się, gdy aplikacja jest aktywna, zgodnie z opisem na stronie Nasłuchuj zmian konfiguracji zarządzanej.

Odczytywanie i stosowanie konfiguracji zarządzanych

Metoda getApplicationRestrictions() zwraca Bundle zawierające pary klucz-wartość dla każdej ustawionej konfiguracji. wszystkie wartości to Boolean, int, String i String[]. Po zainstalowaniu wersji konfiguracje zarządzane Bundle, możesz sprawdzić bieżącą ze standardowymi metodami Bundle dla tych typów danych, takich jak getBoolean() lub getString()

Uwaga: konfiguracje zarządzane Bundle zawiera po jednym elemencie dla każdej konfiguracji, która została jawnie ustawiona przez dostawcy konfiguracji zarządzanych. Nie można jednak założyć, że będzie podana w pakiecie tylko dlatego, że masz zdefiniowaną wartość domyślną w pliku XML konfiguracji zarządzanych.

Aplikacja podejmuje odpowiednie działania na podstawie ustawieniami konfiguracji zarządzanej. Jeśli na przykład aplikacja ma określającą, czy może ona pobierać dane przez i okazuje się, że jest ustawiona na połączenie z siecią komórkową. false, musisz wyłączyć pobieranie danych, chyba że urządzenie jest połączone z siecią Wi-Fi, tak jak w tym przykładowym kodzie:

val appCanUseCellular: Boolean =
        if (appRestrictions.containsKey("downloadOnCellular")) {
            appRestrictions.getBoolean("downloadOnCellular")
        } else {
            // cellularDefault is a boolean using the restriction's default value
            cellularDefault
        }

if (!appCanUseCellular) {
    // ...turn off app's cellular-download functionality
    // ...show appropriate notices to user
}

boolean appCanUseCellular;

if (appRestrictions.containsKey("downloadOnCellular")) {
    appCanUseCellular = appRestrictions.getBoolean("downloadOnCellular");
} else {
    // cellularDefault is a boolean using the restriction's default value
    appCanUseCellular = cellularDefault;
}

if (!appCanUseCellular) {
    // ...turn off app's cellular-download functionality
    // ...show appropriate notices to user
}

Aby zastosować wiele ograniczeń zagnieżdżonych, przeczytaj artykuł bundle_array wpis ograniczenia jako zbiór Parcelable obiektów i przesyłać ją jako Bundle. W tym przykładzie konfiguracja każdej sieci VPN dane są analizowane i wykorzystywane do tworzenia listy dostępnych połączeń z serwerem:

// VpnConfig is a sample class used store config data, not defined
val vpnConfigs = mutableListOf<VpnConfig>()

val parcelables: Array<out Parcelable>? =
        appRestrictions.getParcelableArray("vpn_configuration_list")

if (parcelables?.isNotEmpty() == true) {
    // iterate parcelables and cast as bundle
    parcelables.map { it as Bundle }.forEach { vpnConfigBundle ->
        // parse bundle data and store in VpnConfig array
        vpnConfigs.add(VpnConfig()
                .setServer(vpnConfigBundle.getString("vpn_server"))
                .setUsername(vpnConfigBundle.getString("vpn_username"))
                .setPassword(vpnConfigBundle.getString("vpn_password")))
    }
}

if (vpnConfigs.isNotEmpty()) {
    // ...choose a VPN configuration or prompt user to select from list
}

// VpnConfig is a sample class used store config data, not defined
List<VpnConfig> vpnConfigs = new ArrayList<>();

Parcelable[] parcelables =
    appRestrictions.getParcelableArray("vpn_configuration_list");

if (parcelables != null && parcelables.length > 0) {
    // iterate parcelables and cast as bundle
    for (int i = 0; i < parcelables.length; i++) {
        Bundle vpnConfigBundle = (Bundle) parcelables[i];
        // parse bundle data and store in VpnConfig array
        vpnConfigs.add(new VpnConfig()
            .setServer(vpnConfigBundle.getString("vpn_server"))
            .setUsername(vpnConfigBundle.getString("vpn_username"))
            .setPassword(vpnConfigBundle.getString("vpn_password")));
    }
}

if (!vpnConfigs.isEmpty()) {
    // ...choose a VPN configuration or prompt user to select from list
}

Nasłuchuj zmian konfiguracji zarządzanej

Po każdej zmianie konfiguracji zarządzanej aplikacji system uruchamia Intencja ACTION_APPLICATION_RESTRICTIONS_CHANGED. Aplikacja musi nasłuchiwać tę intencję, dzięki czemu możesz zmienić działanie aplikacji, gdy ustawienia konfiguracji .

Uwaga: intencja ACTION_APPLICATION_RESTRICTIONS_CHANGED jest wysyłana tylko do detektorów zarejestrowanych dynamicznie, a nie dla detektorów zadeklarowanych. w manifeście aplikacji.

Poniższy kod pokazuje, jak dynamicznie zarejestrować odbiornik tę intencję:

val restrictionsFilter = IntentFilter(Intent.ACTION_APPLICATION_RESTRICTIONS_CHANGED)

val restrictionsReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {

        // Get the current configuration bundle
        val appRestrictions = myRestrictionsMgr.applicationRestrictions

        // Check current configuration settings, change your app's UI and
        // functionality as necessary.
    }
}

registerReceiver(restrictionsReceiver, restrictionsFilter)

IntentFilter restrictionsFilter =
    new IntentFilter(Intent.ACTION_APPLICATION_RESTRICTIONS_CHANGED);

BroadcastReceiver restrictionsReceiver = new BroadcastReceiver() {
  @Override public void onReceive(Context context, Intent intent) {

    // Get the current configuration bundle
    Bundle appRestrictions = myRestrictionsMgr.getApplicationRestrictions();

    // Check current configuration settings, change your app's UI and
    // functionality as necessary.
  }
};

registerReceiver(restrictionsReceiver, restrictionsFilter);

Uwaga: zwykle nie trzeba powiadamiać aplikacji. o zmianach konfiguracji po jego wstrzymaniu. Zamiast tego wyrejestruj na odbiorniku, gdy aplikacja jest wstrzymana. Po wznowieniu działania aplikacji najpierw sprawdź bieżące konfiguracje zarządzane (jak omówiono w Sprawdź konfiguracje zarządzane), a następnie zarejestruj Twojego odbiornika, aby upewnić się, że będziesz otrzymywać powiadomienia o zmianach w konfiguracji które pojawiają się, gdy aplikacja jest aktywna.

Wysyłanie do usług EMM opinii o konfiguracji zarządzanej

Po zastosowaniu w aplikacji zmian w konfiguracji zarządzanej warto powiadomić dostawców usług EMM o: stan zmiany. Android obsługuje funkcję o nazwie stany aplikacji z kluczami, którą możesz służy do przesyłania opinii za każdym razem, gdy aplikacja próbuje zastosować zmiany konfiguracji zarządzanej. Ten mogą stanowić potwierdzenie, że aplikacja poprawnie ustawiła konfiguracje zarządzane, jeśli w aplikacji nie zastosowano określonych zmian, pojawi się komunikat o błędzie.

Dostawcy usług EMM mogą pobrać te opinie i wyświetlać je w konsolach dla działu IT do wyświetlenia przez administratorów. Więcej informacji znajdziesz w artykule Przesyłanie opinii o aplikacji do dostawców usług EMM. informacje na dany temat, w tym szczegółowy przewodnik na temat dodawania do aplikacji informacji zwrotnych.

Dodatkowe przykłady kodu

Parametr ManagedConfigurations przykład dokładniej przedstawia wykorzystanie interfejsów API opisanych na tej stronie.