Dodawanie uwierzytelniania do aplikacji Xamarin Forms

Artykuł
06/25/2019

Omówienie

W tym temacie przedstawiono sposób uwierzytelniania użytkowników aplikacji App Service Mobile App z aplikacji klienckiej. W tym samouczku dodasz uwierzytelnianie do projektu szybki start Xamarin Forms przy użyciu dostawcy tożsamości obsługiwanego przez App Service. Po pomyślnym uwierzytelnieniu i autoryzacji przez aplikację mobilną zostanie wyświetlona wartość identyfikatora użytkownika i będzie można uzyskać dostęp do ograniczonych danych tabeli.

Wymagania wstępne

Aby uzyskać najlepszy wynik w tym samouczku, zalecamy, aby najpierw ukończyć samouczek Tworzenie aplikacji Xamarin Forms . Po ukończeniu tego samouczka będziesz mieć projekt Xamarin Forms, który jest wieloplatformową aplikacją TodoList.

Jeśli nie używasz pobranego projektu serwera Szybki start, musisz dodać pakiet rozszerzenia uwierzytelniania do projektu. Aby uzyskać więcej informacji na temat pakietów rozszerzeń serwera, zobacz Praca z zestawem SDK serwera zaplecza platformy .NET dla usługi Azure Mobile Apps.

Rejestrowanie aplikacji w celu uwierzytelniania i konfigurowanie App Services

Najpierw należy zarejestrować aplikację w witrynie dostawcy tożsamości, a następnie ustawić poświadczenia wygenerowane przez dostawcę w Mobile Apps danych.

Skonfiguruj preferowanego dostawcę tożsamości, korzystając z instrukcji specyficznych dla dostawcy:
Powtórz poprzednie kroki dla każdego dostawcy, którego chcesz obsługiwać w aplikacji.

Dodawanie aplikacji do adresów URL dozwolonego zewnętrznego przekierowania

Bezpieczne uwierzytelnianie wymaga zdefiniowania nowego schematu adresu URL dla aplikacji. Dzięki temu system uwierzytelniania może przekierować z powrotem do aplikacji po zakończeniu procesu uwierzytelniania. W tym samouczku używamy nazwy aplikacji schematu adresu URL w całym. Możesz jednak użyć dowolnego schematu adresów URL, który wybierzesz. Powinna być unikatowa dla Twojej aplikacji mobilnej. Aby włączyć przekierowanie po stronie serwera:

W Azure Portal wybierz swoją App Service.
Kliknij opcję menu Uwierzytelnianie/ autoryzacja.
W adresie URL dozwolonego zewnętrznego przekierowania wprowadź wartość url_scheme_of_your_app://easyauth.callback. Wartością url_scheme_of_your_app w tym ciągu jest schemat adresu URL aplikacji mobilnej. Powinien on być zgodne ze specyfikacją normalnego adresu URL protokołu (użyj tylko liter i cyfr i zacznij od litery). Zanotuj ciąg, który wybierzesz, ponieważ konieczne będzie dostosowanie kodu aplikacji mobilnej za pomocą schematu adresu URL w kilku miejscach.
Kliknij przycisk OK.
Kliknij pozycję Zapisz.

Ograniczanie uprawnień do uwierzytelnionych użytkowników

Domyślnie interfejsy API w Mobile Apps mogą być wywoływane anonimowo. Następnie należy ograniczyć dostęp tylko do uwierzytelnionych klientów.

Node.js (za pośrednictwem Azure Portal):

W ustawieniach Mobile Apps kliknij pozycję Łatwe tabele i wybierz tabelę. Kliknij pozycję Zmień uprawnienia, wybierz opcję Dostęp uwierzytelniony tylko dla wszystkich uprawnień, a następnie kliknij przycisk Zapisz.
.NET back end (C#):

W projekcie serwera przejdź do plikówControllersTodoItemController.cs>. Dodaj atrybut [Authorize] do klasy TodoItemController w następujący sposób. Aby ograniczyć dostęp tylko do określonych metod, można również zastosować ten atrybut tylko do tych metod, a nie do klasy . Ponownie opublikować projekt serwera.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js zaplecza (za pośrednictwem Node.js kodu):

Aby wymagać uwierzytelniania w celu uzyskania dostępu do tabeli, dodaj następujący wiersz do Node.js skryptu serwera:
```
  table.access = 'authenticated';
```
Aby uzyskać więcej informacji, zobacz Uwierzytelnianie wymagane w celu uzyskania dostępu do tabel. Aby dowiedzieć się, jak pobrać projekt kodu szybkiego startu ze swojej witryny, zobacz How to: Download the Node.js backend quickstart code project using Git (Jak pobrać projekt kodu szybkiego startu zaplecza przy użyciu usługi Git).

Dodawanie uwierzytelniania do biblioteki klas przenośnych

Mobile Apps używa metody rozszerzenia LoginAsync w aplikacji MobileServiceClient, aby zalogować użytkownika przy użyciu App Service uwierzytelniania. W tym przykładzie użyto przepływu uwierzytelniania zarządzanego przez serwer, który wyświetla interfejs logowania dostawcy w aplikacji. Aby uzyskać więcej informacji, zobacz Uwierzytelnianie zarządzane przez serwer. Aby zapewnić lepsze środowisko użytkownika w aplikacji produkcyjnej, należy rozważyć użycie uwierzytelniania zarządzanego przez klienta.

Aby uwierzytelnić się za pomocą projektu Xamarin Forms, zdefiniuj interfejs IAuthenticate w bibliotece klas przenośnych dla aplikacji. Następnie dodaj przycisk Zaloguj się do interfejsu użytkownika zdefiniowanego w bibliotece klas przenośnych, który można kliknąć, aby rozpocząć uwierzytelnianie. Dane są ładowane z zaplecza aplikacji mobilnej po pomyślnym uwierzytelnieniu.

Zaim implementuj interfejs IAuthenticate dla każdej platformy obsługiwanej przez aplikację.

W Visual Studio lub Xamarin Studio app.cs z projektu o nazwie Portable (projekt portable class library), a następnie dodaj następującą using instrukcje:
```
 ```csharp
 using System.Threading.Tasks;
 ```
```
W app.cs dodaj następującą definicję IAuthenticate interfejsu bezpośrednio przed definicją App klasy.
```
 ```csharp
 public interface IAuthenticate
 {
     Task<bool> Authenticate();
 }
 ```
```

Aby zainicjować interfejs z implementacją specyficzną dla platformy, dodaj następujące statyczne składowe do klasy App .

 ```csharp
 public static IAuthenticate Authenticator { get; private set; }

 public static void Init(IAuthenticate authenticator)
 {
     Authenticator = authenticator;
 }
 ```

Otwórz plik TodoList.xaml z projektu Portable Class Library i dodaj następujący element Button w elemencie układu buttonsPanel po istniejącym przycisku:
```
 ```xml
   <Button x:Name="loginButton" Text="Sign-in" MinimumHeightRequest="30"
     Clicked="loginButton_Clicked"/>
 ```
```
Ten przycisk wyzwala uwierzytelnianie zarządzane przez serwer za pomocą zaplecza aplikacji mobilnej.
Otwórz bibliotekę TodoList.xaml.cs z projektu Portable Class Library, a następnie dodaj następujące pole do TodoList klasy :
```
 ```csharp
 // Track whether the user has authenticated.
 bool authenticated = false;
 ```
```

Zastąp metodę OnAppearing następującym kodem:

 ```csharp
 protected override async void OnAppearing()
 {
     base.OnAppearing();

     // Refresh items only when authenticated.
     if (authenticated == true)
     {
         // Set syncItems to true in order to synchronize the data
         // on startup when running in offline mode.
         await RefreshItems(true, syncItems: false);

         // Hide the Sign-in button.
         this.loginButton.IsVisible = false;
     }
 }
 ```

Ten kod zapewnia, że dane są odświeżane z usługi tylko po uwierzytelnieniu.

Dodaj następującą obsługę zdarzenia Clicked do klasy TodoList :

 ```csharp
 async void loginButton_Clicked(object sender, EventArgs e)
 {
     if (App.Authenticator != null)
         authenticated = await App.Authenticator.Authenticate();

     // Set syncItems to true to synchronize the data on startup when offline is enabled.
     if (authenticated == true)
         await RefreshItems(true, syncItems: false);
 }
 ```

Zapisz zmiany i ponownie skompilowaj projekt biblioteki klas przenośnych, weryfikując brak błędów.

Dodawanie uwierzytelniania do aplikacji systemu Android

W tej sekcji pokazano, jak zaimplementować interfejs IAuthenticate w projekcie aplikacji systemu Android. Pomiń tę sekcję, jeśli nie obsługujesz urządzeń z systemem Android.

W Visual Studio lub Xamarin Studio kliknij prawym przyciskiem myszy projekt droid, a następnie ustaw jako startowy Project.
Naciśnij klawisz F5, aby uruchomić projekt w debugerze, a następnie sprawdź, czy nieobsługiwany wyjątek z kodem stanu 401 (Brak autoryzacji) jest wywoływany po uruchomieniu aplikacji. Kod 401 jest wytwarzanych, ponieważ dostęp do zaplecza jest ograniczony tylko do autoryzowanych użytkowników.
Otwórz aplikację MainActivity.cs w projekcie systemu Android i dodaj następujące using instrukcje:
```
 ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 ```
```

Zaktualizuj klasę MainActivity , aby zaimplementować interfejs IAuthenticate w następujący sposób:

 ```csharp
 public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsApplicationActivity, IAuthenticate
 ```

Zaktualizuj klasę MainActivity , dodając pole MobileServiceUser i metodę Authenticate , która jest wymagana przez interfejs IAuthenticate , w następujący sposób:

 ```csharp
 // Define an authenticated user.
 private MobileServiceUser user;

 public async Task<bool> Authenticate()
 {
     var success = false;
     var message = string.Empty;
     try
     {
         // Sign in with Facebook login using a server-managed flow.
         user = await TodoItemManager.DefaultManager.CurrentClient.LoginAsync(this, 
             MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
         if (user != null)
         {
             message = string.Format("you are now signed-in as {0}.",
                 user.UserId);
             success = true;
         }
     }
     catch (Exception ex)
     {
         message = ex.Message;
     }

     // Display the success or failure message.
     AlertDialog.Builder builder = new AlertDialog.Builder(this);
     builder.SetMessage(message);
     builder.SetTitle("Sign-in result");
     builder.Create().Show();

     return success;
 }

 public override void OnResume()
 {
     base.OnResume();
     Xamarin.Essentials.Platform.OnResume();
 }
 ```

Jeśli używasz dostawcy tożsamości innego niż Facebook, wybierz inną wartość dla dostawcy MobileServiceAuthenticationProvider.

Zaktualizuj plik AndroidManifest.xml , dodając następujący kod XML wewnątrz <application> elementu :

<activity android:name="com.microsoft.windowsazure.mobileservices.authentication.RedirectUrlActivity" android:launchMode="singleTop" android:noHistory="true">
  <intent-filter>
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <data android:scheme="{url_scheme_of_your_app}" android:host="easyauth.callback" />
  </intent-filter>
</activity>

Zastąp {url_scheme_of_your_app} go schematem adresu URL.

Dodaj następujący kod do metody OnCreate klasy MainActivity przed wywołaniem metody LoadApplication():
```
 ```csharp
 // Initialize the authenticator before loading the app.
 App.Init((IAuthenticate)this);
 ```
```
Ten kod zapewnia zainicjowanie wystawcy uwierzytelnień przed ładowaniem aplikacji.
Odbuduj aplikację, uruchom ją, a następnie zaloguj się przy użyciu wybranego dostawcy uwierzytelniania i sprawdź, czy możesz uzyskać dostęp do danych jako uwierzytelniony użytkownik.

Rozwiązywanie problemów

Aplikacja ulegała awarii z Java.Lang.NoSuchMethodError: No static method startActivity

W niektórych przypadkach konflikty w pakietach pomocy technicznej są wyświetlane jako ostrzeżenie w programie Visual Studio, ale aplikacja ulega awarii z tym wyjątkiem w czasie wykonywania. W takim przypadku należy upewnić się, że wszystkie pakiety pomocy technicznej przywołyne w projekcie mają tę samą wersję. Pakiet NuGet usługi Azure Mobile Apps ma zależność Xamarin.Android.Support.CustomTabs dla platformy Android, więc jeśli projekt używa nowszych pakietów dla pomocy technicznej, musisz bezpośrednio zainstalować ten pakiet w wymaganej wersji w celu uniknięcia konfliktów.

Dodawanie uwierzytelniania do aplikacji systemu iOS

W tej sekcji pokazano, jak zaimplementować interfejs IAuthenticate w projekcie aplikacji systemu iOS. Pomiń tę sekcję, jeśli nie obsługujesz urządzeń z systemem iOS.

W Visual Studio lub Xamarin Studio kliknij prawym przyciskiem myszy projekt systemu iOS, a następnie wybierz pozycję Ustaw jako Project.
Naciśnij klawisz F5, aby uruchomić projekt w debugerze, a następnie sprawdź, czy nieobsłużony wyjątek z kodem stanu 401 (Brak autoryzacji) jest wywoływany po uruchomieniu aplikacji. Odpowiedź 401 jest wytwarzanych, ponieważ dostęp do zaplecza jest ograniczony tylko do autoryzowanych użytkowników.

Otwórz aplikację AppDelegate.cs w projekcie systemu iOS i dodaj następujące using instrukcje:

 ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 ```

Zaktualizuj klasę AppDelegate , aby zaimplementować interfejs IAuthenticate w następujący sposób:

 ```csharp
 public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate, IAuthenticate
 ```

Zaktualizuj klasę AppDelegate , dodając pole MobileServiceUser i metodę Authenticate , która jest wymagana przez interfejs IAuthenticate w następujący sposób:

 ```csharp
 // Define an authenticated user.
 private MobileServiceUser user;

 public async Task<bool> Authenticate()
 {
     var success = false;
     var message = string.Empty;
     try
     {
         // Sign in with Facebook login using a server-managed flow.
         if (user == null)
         {
             user = await TodoItemManager.DefaultManager.CurrentClient
                 .LoginAsync(UIApplication.SharedApplication.KeyWindow.RootViewController,
                 MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
             if (user != null)
             {
                 message = string.Format("You are now signed-in as {0}.", user.UserId);
                 success = true;
             }
         }
     }
     catch (Exception ex)
     {
        message = ex.Message;
     }

     // Display the success or failure message.
     UIAlertController avAlert = UIAlertController.Create("Sign-in result", message, UIAlertControllerStyle.Alert);
     avAlert.AddAction(UIAlertAction.Create("OK", UIAlertActionStyle.Default, null));
     UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(avAlert, true, null);

     return success;
 }
 ```

Jeśli używasz dostawcy tożsamości innego niż Facebook, wybierz inną wartość dla [MobileServiceAuthenticationProvider].

Zaktualizuj klasę AppDelegate , dodając przeciążenie metody OpenUrl w następujący sposób:

 ```csharp
 public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
 {
     if (TodoItemManager.DefaultManager.CurrentClient.ResumeWithURL(app, url, options))
         return true;
     return base.OpenUrl(app, url, options);
 }
 ```

Dodaj następujący wiersz kodu do metody FinishedLaunching przed wywołaniem metody LoadApplication():
```
 ```csharp
 App.Init(this);
 ```
```
Ten kod zapewnia zainicjowanie wystawcy uwierzytelnień przed załadowaniem aplikacji.
Otwórz info.plist i dodaj typ adresu URL. W polu Identyfikator ustaw nazwę, a w polu Schematy adresów URL ustaw schemat adresu URL aplikacji, a w polu Rola wartość Brak.
Odbuduj aplikację, uruchom ją, a następnie zaloguj się przy użyciu wybranego dostawcy uwierzytelniania i sprawdź, czy możesz uzyskać dostęp do danych jako uwierzytelniony użytkownik.

Dodawanie uwierzytelniania do Windows 10 (w tym Telefon) aplikacji

W tej sekcji pokazano, jak zaimplementować interfejs IAuthenticate w projektach Windows 10 aplikacji. Te same kroki dotyczą platforma uniwersalna systemu Windows (UWP), ale przy użyciu projektu platformy uniwersalnej systemu Windows (z zanotami zmian). Pomiń tę sekcję, jeśli nie obsługujesz Windows urządzeń.

W Visual Studio kliknij prawym przyciskiem myszy projekt platformy uniwersalnej systemu Windows, a następnie ustaw jako startowy Project.
Naciśnij klawisz F5, aby uruchomić projekt w debugerze, a następnie sprawdź, czy nieobsłużony wyjątek z kodem stanu 401 (Brak autoryzacji) jest wywoływany po uruchomieniu aplikacji. Odpowiedź 401 występuje, ponieważ dostęp do zaplecza jest ograniczony tylko do autoryzowanych użytkowników.
Otwórz mainPage.xaml.cs dla projektu Windows aplikacji i dodaj następujące using instrukcje:
```
 ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 using Windows.UI.Popups;
 using <your_Portable_Class_Library_namespace>;
 ```
```
Zastąp <your_Portable_Class_Library_namespace> elementu przestrzenią nazw biblioteki klas przenośnych.
Zaktualizuj klasę MainPage , aby zaimplementować interfejs IAuthenticate w następujący sposób:
```
 public sealed partial class MainPage : IAuthenticate
```

Zaktualizuj klasę MainPage , dodając pole MobileServiceUser i metodę Authenticate , która jest wymagana przez interfejs IAuthenticate , w następujący sposób:

 ```csharp
 // Define an authenticated user.
 private MobileServiceUser user;

 public async Task<bool> Authenticate()
 {
     string message = string.Empty;
     var success = false;

     try
     {
         // Sign in with Facebook login using a server-managed flow.
         if (user == null)
         {
             user = await TodoItemManager.DefaultManager.CurrentClient
                 .LoginAsync(MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
             if (user != null)
             {
                 success = true;
                 message = string.Format("You are now signed-in as {0}.", user.UserId);
             }
         }

     }
     catch (Exception ex)
     {
         message = string.Format("Authentication Failed: {0}", ex.Message);
     }

     // Display the success or failure message.
     await new MessageDialog(message, "Sign-in result").ShowAsync();

     return success;
 }
 ```