Hitelesítés hozzáadása a Xamarin Forms-alkalmazáshoz

Cikk
06/25/2019

Áttekintés

Ez a témakör bemutatja, hogyan hitelesítheti egy App Service mobilalkalmazás felhasználóit az ügyfélalkalmazásból. Ebben az oktatóanyagban hitelesítést fog hozzáadni a Xamarin Forms gyorsindítási projekthez egy, a Xamarin Forms által támogatott identitásszolgáltató App Service. Miután sikeresen hitelesítette és engedélyezte a Mobilalkalmazást, megjelenik a felhasználói azonosító értéke, és hozzáférhet a korlátozott táblaadatokhoz.

Előfeltételek

A legjobb eredmény érdekében javasoljuk, hogy először a Create a Xamarin Forms app (Xamarin Forms-alkalmazás létrehozása) oktatóanyagot töltse le. Az oktatóanyag befejezése után egy többplatformos TodoList-alkalmazással fog Xamarin Forms-projekttel fog fogni.

Ha nem használja a letöltött gyors indítási kiszolgálóprojektet, hozzá kell adni a hitelesítési bővítménycsomagot a projekthez. További információ a kiszolgálóbővítmény-csomagokról: Az Azure-hoz készült .NET háttérkiszolgálói SDK Mobile Apps.

Az alkalmazás regisztrálása hitelesítéshez és App Services

Először regisztrálnia kell az alkalmazást egy identitásszolgáltató webhelyén, majd be kell állítania a szolgáltató által létrehozott hitelesítő adatokat a Mobile Apps háttéralkalmazásban.

Konfigurálja az előnyben részesített identitásszolgáltatót a szolgáltatóra vonatkozó utasítások szerint:
Ismételje meg az előző lépéseket minden olyan szolgáltatónál, amit támogatni szeretne az alkalmazásban.

Az alkalmazás hozzáadása az engedélyezett külső átirányítási URL-címekhez

A biztonságos hitelesítéshez új URL-sémát kell definiálni az alkalmazáshoz. Ez lehetővé teszi, hogy a hitelesítési rendszer visszairányítsa az alkalmazást a hitelesítési folyamat befejezése után. Ebben az oktatóanyagban az alkalmazásnév URL-sémát használjuk végig. Azonban bármilyen URL-sémát használhat. A mobilalkalmazás egyedinek kell lennie. Az átirányítás engedélyezése a kiszolgálóoldalon:

A Azure Portal válassza ki a App Service.
Kattintson a Hitelesítés / Engedélyezés menüpontra.
Az Engedélyezett külső átirányítási URL-címek beállításnál adja meg a következőt: url_scheme_of_your_app://easyauth.callback. Az url_scheme_of_your_app a sztringben a mobilalkalmazás URL-sémája. Egy protokoll normál URL-specifikációját kell követnie (csak betűket és számokat használjon, és betűvel kezdjen). Jegyezze fel a választott sztringet, mivel számos helyen módosítania kell a mobilalkalmazás kódját az URL-sémával.
Kattintson az OK gombra.
Kattintson a Mentés gombra.

A hitelesített felhasználókra vonatkozó engedélyek korlátozása

Alapértelmezés szerint a háttér Mobile Apps API-k névtelenül hívhatóak meg. Ezután korlátoznia kell a hozzáférést csak a hitelesített ügyfelekre.

Node.js háttér (a Azure Portal) segítségével:

A saját Mobile Apps kattintson az Easy Tables (Egyszerű táblák) elemre , és válassza ki a táblát. Kattintson az Engedélyek módosítása elemre, válassza a Csak hitelesített hozzáférés minden engedélyhez lehetőséget, majd kattintson a Mentés gombra.
.NET-háttér (C#):

A kiszolgálóprojektben lépjen a ControllersTodoItemController.cs> fájlra. Adja hozzá az [Authorize] attribútumot a TodoItemController osztályhoz az alábbiak szerint. Ha csak bizonyos metódusok elérésére korlátozza a hozzáférést, ezt az attribútumot a osztály helyett csak azokra a metódusra is alkalmazhatja. Tegye közzé újra a kiszolgálóprojektet.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js háttér (egy kódon Node.js keresztül):

Ha hitelesítést szeretne megkövetelni a táblaeléréshez, adja hozzá a következő sort a Node.js-kiszolgálói szkripthez:
```
  table.access = 'authenticated';
```
További részletekért lásd : How to: Require authentication for access to tables (Hogyan lehet: Hitelesítés megkövetelve a táblákhoz való hozzáféréshez). A gyorsindítási kódprojekt webhelyről való letöltésével kapcsolatos további információkért lásd : Útmutató: A Node.js háttér-rövid útmutató kódprojekt letöltése a Git használatával.

Hitelesítés hozzáadása a hordozható osztálytárhoz

Mobile Apps a MobileServiceClient loginAsync bővítmény metódusával jelentkeztet be egy felhasználót App Service hitelesítéssel. Ez a példa egy kiszolgáló által felügyelt hitelesítési folyamatot használ, amely megjeleníti a szolgáltató bejelentkezési felületét az alkalmazásban. További információ: Kiszolgáló által felügyelt hitelesítés. Annak érdekében, hogy jobb felhasználói élményt nyújtson az éles alkalmazásban, érdemes megfontolni az ügyfél által felügyelt hitelesítés használatát.

Xamarin Forms-projekttel való hitelesítéshez definiáljon egy IAuthenticate felületet az alkalmazás Hordozható osztálytárában. Ezután adjon hozzá egy Bejelentkezés gombot a Hordozható osztálytárban meghatározott felhasználói felülethez, amelyre kattintva elindítja a hitelesítést. A sikeres hitelesítés után a rendszer betölti az adatokat a mobilalkalmazás háttéralkalmazásból.

Implementálja az IAuthenticate felületet az alkalmazás által támogatott összes platformhoz.

A Visual Studio vagy Xamarin Studióban nyissa meg az App.cs-t a projektből a Portable névvel, amely a Portable Class Library projekt, majd adja hozzá a következő using utasítást:
```
 ```csharp
 using System.Threading.Tasks;
 ```
```
Az App.cs fájlban adja hozzá a következő felületdefiníciót IAuthenticate közvetlenül az osztálydefiníció App előtt.
```
 ```csharp
 public interface IAuthenticate
 {
     Task<bool> Authenticate();
 }
 ```
```

A felület platformspecifikus implementációval való inicializáláshoz adja hozzá a következő statikus tagokat az App osztályhoz .

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

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

Nyissa meg a TodoList.xaml elemet a Portable Class Library projektből, és adja hozzá a következő Gomb elemet a buttonsPanel elrendezési elemhez a meglévő gomb után:
```
 ```xml
   <Button x:Name="loginButton" Text="Sign-in" MinimumHeightRequest="30"
     Clicked="loginButton_Clicked"/>
 ```
```
Ez a gomb aktiválja a kiszolgáló által felügyelt hitelesítést a mobilalkalmazás háttéralkalmazásával.
Nyissa meg a TodoList.xaml.cs et a Portable Class Library projektből, majd adja hozzá a következő mezőt a osztályhoz TodoList :
```
 ```csharp
 // Track whether the user has authenticated.
 bool authenticated = false;
 ```
```

Cserélje le az OnAppearing metódust a következő kódra:

 ```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;
     }
 }
 ```

Ez a kód ellenőrzi, hogy az adatok csak a hitelesítés után frissülnek a szolgáltatásból.

Adja hozzá a következő kezelőt a Kattintott eseményhez a TodoList osztályhoz :

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

Mentse a módosításokat, és építse újra a Portable Class Library projektet, és ellenőrizze, hogy nincsenek-e hibák.

Hitelesítés hozzáadása az Android-alkalmazáshoz

Ez a szakasz bemutatja, hogyan valósítható meg az IAuthenticate felület az Android-alkalmazásprojektben. Ha nem támogatja az Android-eszközöket, hagyja ki ezt a szakaszt.

A Visual Studio vagy A Xamarin Studióban kattintson a jobb gombbal a projektre, majd kattintson a Set as StartUp Project.
Nyomja le az F5 billentyűt a projekt hibakeresőben való indításhoz, majd ellenőrizze, hogy az alkalmazás indításakor 401-es (Jogosulatlan) állapotkóddal nem kezelt kivétel történt-e. A 401-es kód azért jön létre, mert a háttéren csak a jogosult felhasználók férhetnek hozzá.
Nyissa meg a MainActivity.cs-t az Android-projektben, és adja hozzá a következő utasításokat using :
```
 ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 ```
```

Frissítse a MainActivity osztályt az IAuthenticate felület megvalósításához a következőképpen:

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

Frissítse a MainActivity osztályt egy MobileServiceUser mező és egy Hitelesítési módszer hozzáadásával, amelyre az IAuthenticate felületnek szüksége van, az alábbiak szerint:

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

Ha a Facebooktól eltérő identitásszolgáltatót használ, válasszon egy másik értéket a MobileServiceAuthenticationProvider számára.

Frissítse a AndroidManifest.xml fájlt úgy, hogy hozzáadja a következő XML-t a elemhez <application> :

<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>

Cserélje le {url_scheme_of_your_app} a helyére a saját URL-sémáját.

Adja hozzá a következő kódot a MainActivity osztály OnCreate metódushoz a hívása előttLoadApplication():
```
 ```csharp
 // Initialize the authenticator before loading the app.
 App.Init((IAuthenticate)this);
 ```
```
Ez a kód biztosítja, hogy a hitelesítő inicializálva legyen az alkalmazás betöltése előtt.
Építse újra az alkalmazást, futtassa, majd jelentkezzen be a kiválasztott hitelesítésszolgáltatóval, és ellenőrizze, hogy hozzá tud-e férni az adatokhoz hitelesített felhasználóként.

Hibaelhárítás

Az alkalmazás a következővel összeomlott: Java.Lang.NoSuchMethodError: No static method startActivity

Bizonyos esetekben a támogatási csomagok ütközése csak figyelmeztetésként jelenik meg a Visual Studióban, de az alkalmazás futásidőben összeomlik, ez a kivétel. Ebben az esetben meg kell győződni arról, hogy a projektben hivatkozott összes támogatási csomag azonos verziójú. Az Azure Mobile Apps NuGet csomag Android platform esetén Xamarin.Android.Support.CustomTabs-függőséggel rendelkezik, így ha a projektjében újabb támogatási csomagokat használ, akkor az ütközések elkerülése érdekében közvetlenül kell telepítenie ennek a csomagnak a szükséges verzióját.

Hitelesítés hozzáadása az iOS-alkalmazáshoz

Ez a szakasz bemutatja, hogyan valósítható meg az IAuthenticate felület az iOS-alkalmazásprojektben. Ha nem támogatja az iOS-eszközöket, hagyja ki ezt a szakaszt.

A Visual Studio Xamarin Studióban kattintson a jobb gombbal az iOS-projektre, majd válassza a Beállítás indítási Project.
Nyomja le az F5 billentyűt a projekt hibakeresőben való indításhoz, majd ellenőrizze, hogy az alkalmazás indításakor 401-es (Jogosulatlan) állapotkóddal nem kezelt kivétel történt-e. A 401-es válasz azért jön létre, mert a háttéren csak a jogosult felhasználók férhetnek hozzá.
Nyissa meg az AppDelegate.cs-t az iOS-projektben, és adja hozzá a következő utasításokat using :
```
 ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 ```
```

Frissítse az AppDelegate osztályt az IAuthenticate felület megvalósításához a következőképpen:

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

Frissítse az AppDelegate osztályt egy MobileServiceUser mező és egy Hitelesítési módszer hozzáadásával, amelyre az IAuthenticate felületnek szüksége van, az alábbiak szerint:

 ```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;
 }
 ```

Ha a Facebooktól eltérő identitásszolgáltatót használ, válasszon egy másik értéket a [MobileServiceAuthenticationProvider] számára.

Frissítse az AppDelegate osztályt az OpenUrl-metódus túlterhelésének hozzáadásával az alábbiak szerint:

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

Adja hozzá a következő kódsort a FinishedLaunching metódushoz a hívása előtt LoadApplication():
```
 ```csharp
 App.Init(this);
 ```
```
Ez a kód biztosítja, hogy a hitelesítő inicializálva legyen az alkalmazás betöltése előtt.
Nyissa meg az Info.plist-et, és adjon meg egy URL-típust. Állítsa az Azonosítót egy ön által választott névre, az URL-sémákat az alkalmazás URL-sémára, a Szerepkört pedig Nincsre.
Építse újra az alkalmazást, futtassa, majd jelentkezzen be a kiválasztott hitelesítésszolgáltatóval, és ellenőrizze, hogy hozzá tud-e férni az adatokhoz hitelesített felhasználóként.

Hitelesítés hozzáadása Windows 10 alkalmazásprojekthez (Telefon is)

Ez a szakasz bemutatja, hogyan valósítható meg az IAuthenticate felület az Windows 10 projektekben. Ugyanezek a lépések vonatkoznak a Univerzális Windows-platform (UWP) projektekre, de az UWP-projekt használata (a feljegyzett módosításokkal). Hagyja ki ezt a szakaszt, ha nem támogatja a Windows eszközöket.

A Visual Studio kattintson a jobb gombbal az UWP-projektre, majd válassza a Set as StartUp Project.
Nyomja le az F5 billentyűt a projekt hibakeresőben való indításhoz, majd ellenőrizze, hogy az alkalmazás indításakor 401-es (Jogosulatlan) állapotkóddal nem kezelt kivétel történt-e. A 401-es válasz azért történik, mert a háttéren csak a jogosult felhasználók férhetnek hozzá.
Nyissa meg a MainPage.xaml.cs Windows alkalmazásprojekthez, és adja hozzá a következő utasításokatusing:
```
 ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 using Windows.UI.Popups;
 using <your_Portable_Class_Library_namespace>;
 ```
```
Cserélje <your_Portable_Class_Library_namespace> le a helyére a hordozható osztálytár névterét.
Frissítse a MainPage osztályt az IAuthenticate felület megvalósításához a következőképpen:
```
 public sealed partial class MainPage : IAuthenticate
```

Frissítse a MainPage osztályt egy MobileServiceUser mező és egy Hitelesítési módszer hozzáadásával, amelyre az IAuthenticate felületnek szüksége van, az alábbiak szerint:

 ```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;
 }
 ```