Poradnik: Dodawanie trybu współdzielenia urządzenia do aplikacji na system Android

Dotyczy: Dzierżawcy pracowników (dowiedz się więcej)

W tym samouczku deweloperzy systemu Android dowiedzą się, jak dodać obsługę trybu współdzielonego urządzenia w aplikacji systemu Android z wykorzystaniem biblioteki Microsoft Authentication Library (MSAL) dla systemu Android.

W tym samouczku nauczysz się następujących rzeczy:

Tworzenie lub modyfikowanie istniejącej aplikacji systemu Android

Aby ukończyć resztę samouczka, musisz utworzyć nową lub zmodyfikować istniejącą aplikację systemu Android. Jeśli jeszcze tego nie zrobiono, zapoznaj się z samouczkiem biblioteki MSAL dla systemu Android , aby uzyskać wskazówki dotyczące sposobu integrowania biblioteki MSAL z aplikacją systemu Android, logowania użytkownika, wywoływania programu Microsoft Graph i wylogowania użytkownika. Jeśli wolisz używać ukończonego przykładu kodu do nauki i testowania, sklonuj przykładową aplikację z usługi GitHub. Próbka ma zdolność pracy w trybie pojedynczego lub wielu kont.

Dodaj MSAL SDK do lokalnego repozytorium Maven

Jeśli nie używasz przykładowej aplikacji, dodaj bibliotekę MSAL jako zależność w pliku build.gradle, w następujący sposób:

dependencies{
  implementation 'com.microsoft.identity.client.msal:4.9.+'
}

Dodawanie obsługi trybu pojedynczego konta

Aplikacje napisane przy użyciu zestawu SDK biblioteki Microsoft Authentication Library (MSAL) mogą zarządzać jednym kontem lub wieloma kontami. Aby uzyskać szczegółowe informacje, zobacz tryb pojedynczego konta lub tryb wielu kont.

Funkcje Platforma tożsamości Microsoft dostępne dla aplikacji różnią się w zależności od tego, czy aplikacja działa w trybie pojedynczego konta, czy w trybie wielu kont.

Aplikacje w trybie urządzenia udostępnionego działają tylko w trybie pojedynczego konta.

Aplikację można utworzyć w celu obsługi uruchamiania zarówno na urządzeniach osobistych, jak i na urządzeniach udostępnionych. Jeśli aplikacja obecnie obsługuje wiele kont i chcesz korzystać z trybu współdzielonego urządzenia, dodaj obsługę trybu pojedynczego konta.

Możesz również chcieć, aby aplikacja zmieniła swoje zachowanie w zależności od typu urządzenia, na którym jest uruchomiona. Użyj ISingleAccountPublicClientApplication.isSharedDevice(), aby określić, kiedy uruchomić w trybie pojedynczego konta.

Istnieją dwa różne interfejsy reprezentujące typ urządzenia, na których znajduje się aplikacja. Gdy zażądasz wystąpienia aplikacji z mechanizmu aplikacji MSAL, prawidłowy obiekt aplikacji jest udostępniany automatycznie.

Poniższy model obiektów ilustruje typ obiektu, który może zostać odebrany i co oznacza w kontekście urządzenia udostępnionego:

Należy sprawdzić typ obiektu, a następnie rzutować go do odpowiedniego interfejsu, gdy otrzymujesz obiekt PublicClientApplication. Poniższy kod sprawdza tryby wielu kont lub pojedynczego konta i odpowiednio przekształca obiekt aplikacji.

private IPublicClientApplication mApplication;

        // Running in personal-device mode?
        if (mApplication instanceOf IMultipleAccountPublicClientApplication) {
          IMultipleAccountPublicClientApplication multipleAccountApplication = (IMultipleAccountPublicClientApplication) mApplication;
          ...
        // Running in shared-device mode?
        } else if (mApplication instanceOf ISingleAccountPublicClientApplication) {
           ISingleAccountPublicClientApplication singleAccountApplication = (ISingleAccountPublicClientApplication) mApplication;
            ...
        }

Następujące różnice mają zastosowanie w zależności od tego, czy aplikacja jest uruchomiona na urządzeniu udostępnionym, czy osobistym:

Konfigurowanie aplikacji do korzystania z trybu udostępnionego urządzenia

Zapoznaj się z dokumentacją konfiguracji, aby uzyskać więcej informacji na temat konfigurowania pliku konfiguracji.

Ustaw "shared_device_mode_supported" na true w pliku konfiguracji MSAL.

Być może nie planujesz obsługi trybu wielu kont. Może to być możliwe, jeśli nie używasz urządzenia udostępnionego, a użytkownik może zalogować się do aplikacji przy użyciu więcej niż jednego konta w tym samym czasie. Jeśli tak, ustaw "account_mode" na "SINGLE". Gwarantuje to, że aplikacja będzie zawsze otrzymywać ISingleAccountPublicClientApplication, i znacznie upraszcza integrację z MSAL. Wartość "account_mode" domyślna to "MULTIPLE", dlatego ważne jest, aby zmienić tę wartość w pliku konfiguracji, jeśli używasz "single account" trybu.

Oto przykład pliku auth_config.json zawartego wgłównym> katalogures>raw> przykładowej aplikacji:

{
  "client_id": "Client ID after app registration at https://aka.ms/MobileAppReg",
  "authorization_user_agent": "DEFAULT",
  "redirect_uri": "Redirect URI after app registration at https://aka.ms/MobileAppReg",
  "account_mode": "SINGLE",
  "broker_redirect_uri_registered": true,
  "shared_device_mode_supported": true,
  "authorities": [
    {
      "type": "AAD",
      "audience": {
        "type": "AzureADandPersonalMicrosoftAccount",
        "tenant_id": "common"
      }
    }
  ]
}

Wykrywaj tryb urządzenia udostępnionego

Tryb urządzenia udostępnionego umożliwia skonfigurowanie urządzeń z systemem Android do współużytkowania przez wielu pracowników przy jednoczesnym zapewnieniu zarządzania urządzeniami wspieranymi przez usługę Microsoft Identity. Pracownicy mogą szybko logować się do swoich urządzeń i uzyskiwać dostęp do informacji o klientach. Po zakończeniu zmiany lub zadania będą mogli wylogować się ze wszystkich aplikacji na udostępnionym urządzeniu za pomocą jednego kliknięcia, a urządzenie będzie natychmiast gotowe do użycia przez następnego pracownika.

Użyj isSharedDevice() polecenia , aby określić, czy aplikacja jest uruchomiona na urządzeniu, które jest w trybie urządzenia udostępnionego. Aplikacja może użyć tej flagi, aby określić, czy powinna odpowiednio zmodyfikować środowisko użytkownika.

Oto fragment kodu, który pokazuje, jak można użyć polecenia isSharedDevice(). Pochodzi z klasy SingleAccountModeFragment w przykładowej aplikacji.

deviceModeTextView.setText(mSingleAccountApp.isSharedDevice() ? "Shared" : "Non-Shared");

Inicjowanie obiektu PublicClientApplication

Jeśli ustawisz "account_mode":"SINGLE" w pliku konfiguracji biblioteki MSAL, możesz bezpiecznie rzutować zwrócony obiekt aplikacji jako ISingleAccountPublicCLientApplication.

private ISingleAccountPublicClientApplication mSingleAccountApp;

/*Configure your sample app and save state for this activity*/
PublicClientApplication.create(this.getApplicationCOntext(),
  R.raw.auth_config,
  new PublicClientApplication.ApplicationCreatedListener(){
  @Override
  public void onCreated(IPublicClientApplication application){
  mSingleAccountApp = (ISingleAccountPublicClientApplication)application;
  loadAccount();
  }
  @Override
  public void onError(MsalException exception){
  /*Fail to initialize PublicClientApplication */
  }
});

Wykrywanie trybu pojedynczego i wielu kont

Jeśli piszesz aplikację, która będzie używana tylko przez pracowników pierwszej linii na udostępnionym urządzeniu, zalecamy napisanie aplikacji obsługującej tylko tryb pojedynczego konta. Obejmuje to większość aplikacji, które są ukierunkowane na zadania, takie jak aplikacje dokumentacji medycznej, aplikacje faktury i większość aplikacji biznesowych. Uprości to programowanie, ponieważ nie trzeba uwzględniać wielu funkcji zestawu SDK.

Jeśli aplikacja obsługuje wiele kont i tryb udostępnionego urządzenia, należy sprawdzić typ i rzutować do odpowiedniego interfejsu, jak pokazano poniżej.

private IPublicClientApplication mApplication;

        if (mApplication instanceOf IMultipleAccountPublicClientApplication) {
          IMultipleAccountPublicClientApplication multipleAccountApplication = (IMultipleAccountPublicClientApplication) mApplication;
          ...
        } else if (mApplication instanceOf    ISingleAccountPublicClientApplication) {
           ISingleAccountPublicClientApplication singleAccountApplication = (ISingleAccountPublicClientApplication) mApplication;
            ...
        }

Pobierz zalogowanego użytkownika i ustal, czy użytkownik zmienił się na urządzeniu

Metoda loadAccount pobiera konto zalogowanego użytkownika. Metoda onAccountChanged określa, czy zalogowany użytkownik uległ zmianie, a jeśli tak, wyczyść:

private void loadAccount()
{
  mSingleAccountApp.getCurrentAccountAsync(new ISingleAccountPublicClientApplication.CurrentAccountCallback())
  {
    @Override
    public void onAccountLoaded(@Nullable IAccount activeAccount)
    {
      if (activeAccount != null)
      {
        signedInUser = activeAccount;
        mSingleAccountApp.acquireTokenSilentAsync(SCOPES,"http://login.microsoftonline.com/common",getAuthSilentCallback());
      }
    }
    @Override
    public void onAccountChanged(@Nullable IAccount priorAccount, @Nullable Iaccount currentAccount)
    {
      if (currentAccount == null)
      {
        //Perform a cleanup task as the signed-in account changed.
        updateSingedOutUI();
      }
    }
    @Override
    public void onError(@NonNull Exception exception)
    {
    }
  }
}

Globalne logowanie użytkownika

Poniżej przedstawiono logowanie użytkownika na urządzeniu do innych aplikacji korzystających z biblioteki MSAL z aplikacją Authenticator:

private void onSignInClicked()
{
  mSingleAccountApp.signIn(getActivity(), SCOPES, null, getAuthInteractiveCallback());
}

Globalnie wyloguj użytkownika

Poniższe polecenie usuwa zalogowane konto i czyści buforowane tokeny nie tylko z aplikacji, ale także z urządzenia, które jest w trybie udostępnionego urządzenia:

private void onSignOutClicked()
{
  mSingleAccountApp.signOut(new ISingleAccountPublicClientApplication.SignOutCallback()
  {
    @Override
    public void onSignOut()
    {
      updateSignedOutUI();
    }
    @Override
    public void onError(@NonNull MsalException exception)
    {
      /*failed to remove account with an exception*/
    }
  });
}

Odbieranie emisji w celu wykrywania globalnego wylogowania zainicjowanego z innych aplikacji

Aby odebrać emisję zmiany konta, należy zarejestrować odbiornik emisji. Zaleca się rejestrowanie odbiornika transmisji za pomocą odbiorników rejestrowanych w kontekście.

Po odebraniu sygnału zmiany konta natychmiast sprawdź zalogowanego użytkownika i ustal, czy użytkownik zmienił się na urządzeniu. Jeśli zostanie wykryta zmiana, zainicjuj czyszczenie danych dla wcześniej zalogowanego konta. Zaleca się prawidłowe zatrzymywanie wszystkich operacji i czyszczenie danych.

Poniższy fragment kodu pokazuje, jak można zarejestrować odbiornik emisji.

private static final String CURRENT_ACCOUNT_CHANGED_BROADCAST_IDENTIFIER = "com.microsoft.identity.client.sharedmode.CURRENT_ACCOUNT_CHANGED";
private BroadcastReceiver mAccountChangedBroadcastReceiver;
private void registerAccountChangeBroadcastReceiver(){
    mAccountChangedBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            //INVOKE YOUR PRIOR ACCOUNT CLEAN UP LOGIC HERE
        }
    };
    IntentFilter filter = new

    IntentFilter(CURRENT_ACCOUNT_CHANGED_BROADCAST_IDENTIFIER);
    this.registerReceiver(mAccountChangedBroadcastReceiver, filter);
}

Zarejestruj aplikację i ustaw swoją dzierżawę na potrzeby testowania

Aby skonfigurować aplikację i umieścić urządzenie w trybie współdzielonym, musisz zarejestrować aplikację w dzierżawie swojej organizacji. Następnie należy podać te wartości w auth_config.json , aby aplikacja mogła działać poprawnie.

Aby uzyskać informacje na temat tego, jak to zrobić, zobacz Rejestrowanie aplikacji.

Wybierz opcję Wprowadź tę zmianę dla mnie, a następnie podaj wartości wymagane przez Szybki Start. Po zakończeniu identyfikator Entra firmy Microsoft generuje wszystkie potrzebne pliki konfiguracji.

Na potrzeby testowania skonfiguruj następujące role w dzierżawie: co najmniej dwóch pracowników i administratora urządzeń chmurowych. Aby ustawić administratora urządzeń w chmurze, należy zmodyfikować role organizacyjne. W centrum administracyjnym firmy Microsoft Entra przejdź do ról organizacyjnych, wybierając pozycję Entra ID>Roles & admins>Wszystkie role, a następnie wybierz pozycję Administrator urządzeń w chmurze. Dodaj użytkowników, którzy mogą umieścić urządzenie w trybie udostępnionym.

Uruchamianie przykładowej aplikacji

Przykładowa aplikacja to prosta aplikacja, która będzie wywoływać interfejs API programu Graph w organizacji. Przy pierwszym uruchomieniu zostaniesz poproszony o wyrażenie zgody, ponieważ aplikacja jest nowa na Twoim koncie pracownika.

Następne kroki

Skonfiguruj urządzenie z systemem Android do uruchamiania aplikacji w trybie urządzenia udostępnionego i przetestuj aplikację.