Sdílet prostřednictvím

Přidání ověřování do aplikace Xamarin Forms

  • Článek

Přehled

v tomto tématu se dozvíte, jak ověřit uživatele App Service mobilní aplikace z klientské aplikace. V tomto kurzu přidáte do projektu pro rychlý Start formulářů Xamarin ověřování pomocí zprostředkovatele identity, který je podporován App Service. Po úspěšném ověření a autorizaci vaší mobilní aplikace se zobrazí hodnota ID uživatele a budete mít přístup k omezeným datům tabulky.

Požadavky

Pro dosažení co nejlepších výsledků v tomto kurzu doporučujeme, abyste nejdřív dokončili kurz Vytvoření aplikace pro tvorbu formulářů Xamarin . Po dokončení tohoto kurzu budete mít projekt Xamarin Forms, který je aplikací TodoList s více platformami.

Pokud nepoužíváte stažený projekt serveru pro rychlé zahájení, je nutné přidat balíček rozšíření ověřování do projektu. Další informace o balíčcích rozšíření serveru najdete v tématu práce s back-end serverem .NET SDK pro Azure Mobile Apps.

Zaregistrovat aplikaci pro ověřování a nakonfigurovat App Services

Nejdřív je potřeba zaregistrovat aplikaci na webu zprostředkovatele identity a potom nastavit přihlašovací údaje vygenerované zprostředkovatelem v Mobile Apps back-endu.

  1. Podle pokynů pro konkrétního poskytovatele nakonfigurujte preferovaného zprostředkovatele identity:

  2. Opakujte předchozí kroky pro každého poskytovatele, kterého chcete ve své aplikaci podporovat.

Přidání aplikace do povolených externích adres URL pro přesměrování

Zabezpečené ověřování vyžaduje, abyste pro svou aplikaci nadefinovali nové schéma URL. To umožňuje, aby systém ověřování po dokončení procesu ověřování přesměroval zpátky do vaší aplikace. V tomto kurzu používáme celé rozhraní příkazového schématu URL. Můžete ale použít jakékoli schéma URL, které si zvolíte. Měl by být jedinečný pro vaši mobilní aplikaci. Zapnutí přesměrování na straně serveru:

  1. v Azure Portalvyberte App Service.

  2. Klikněte na možnost nabídka ověřování/autorizace .

  3. Do pole povolené externí adresy URL pro přesměrovánízadejte url_scheme_of_your_app://easyauth.callback . Url_scheme_of_your_app v tomto řetězci je schéma adresy URL vaší mobilní aplikace. Měla by následovat po běžné specifikaci adresy URL protokolu (použijte pouze písmena a čísla a začněte písmenem). Měli byste si poznamenat řetězec, který si zvolíte, protože budete muset upravit kód mobilní aplikace pomocí schématu adresy URL na několika místech.

  4. Klikněte na OK.

  5. Klikněte na Uložit.

Omezení oprávnění pro ověřené uživatele

Ve výchozím nastavení lze rozhraní API v Mobile Appsm back-endu vyvolat anonymně. Dál je potřeba omezit přístup jenom na ověřené klienty.

  • Node.js back-end (přes Azure Portal) :

    V nastavení Mobile Apps klikněte na možnost snadné tabulky a vyberte tabulku. Klikněte na změnit oprávnění, vyberte ověřený přístup jenom pro všechna oprávnění a pak klikněte na Uložit.

  • Back-end .NET (C#):

    V projektu serveru přejděte na Controllers>TodoItemController. cs. [Authorize]Přidejte atribut do třídy TodoItemController následujícím způsobem. Chcete-li omezit přístup pouze na konkrétní metody, můžete také použít tento atribut pouze pro tyto metody namísto třídy. Publikujte projekt serveru znovu.

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Node.js back-end (přes Node.js kód) :

    Pokud chcete pro přístup k tabulce vyžadovat ověření, přidejte do skriptu Node.js serveru následující řádek:

      table.access = 'authenticated';

    Další podrobnosti najdete v tématu How to: vyžadovat ověřování pro přístup k tabulkám. Informace o tom, jak stáhnout projekt kódu pro rychlé zprovoznění z webu, najdete v tématu How to: download Node.js back-endu pro rychlé nasazení kódu pomocí Gitu.

Přidání ověřování do přenositelné knihovny tříd

Mobile Apps používá metodu rozšíření LoginAsync na MobileServiceClient k přihlášení uživatele s ověřováním App Service. Tato ukázka používá tok ověřování spravovaný serverem, který zobrazuje rozhraní pro přihlášení zprostředkovatele v aplikaci. Další informace najdete v tématu ověřování spravované serverem. Pro zajištění lepšího uživatelského prostředí v produkční aplikaci byste měli zvážit místo toho, abyste používali ověřování spravovaného klientem.

Pro ověření pomocí projektu Xamarin Forms definujte rozhraní IAuthenticate v přenositelné knihovně tříd pro aplikaci. Pak přidejte tlačítko pro přihlášení k uživatelskému rozhraní definovanému v knihovně přenosných tříd, na kterou kliknete, chcete-li spustit ověřování. Data se po úspěšném ověření načítají z back-endu mobilní aplikace.

Implementujte rozhraní IAuthenticate pro každou platformu, kterou vaše aplikace podporuje.

  1. v Visual Studio nebo Xamarin Studio otevřete App. cs z projektu s možností přenosné v názvu, který je přenosná knihovna tříd projektu, a přidejte následující using příkaz:

     ```csharp
 using System.Threading.Tasks;
 ```

  2. V App. cs přidejte následující IAuthenticate definici rozhraní těsně před App definici třídy.

     ```csharp
 public interface IAuthenticate
 {
     Task<bool> Authenticate();
 }
 ```

  3. Chcete-li inicializovat rozhraní s implementací specifickou pro konkrétní platformu, přidejte do třídy App následující statické členy.

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

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

  4. Otevřete TodoList. XAML z přenositelného projektu knihovny tříd, přidejte následující element Button v elementu rozložení buttonsPanel po existujícím tlačítku:

     ```xml
   <Button x:Name="loginButton" Text="Sign-in" MinimumHeightRequest="30"
     Clicked="loginButton_Clicked"/>
 ```

    Toto tlačítko aktivuje ověřování spravované serverem pomocí back-endu vaší mobilní aplikace.

  5. Otevřete TodoList. XAML. cs z přenositelného projektu knihovny tříd a potom do TodoList třídy přidejte následující pole:

     ```csharp
 // Track whether the user has authenticated.
 bool authenticated = false;
 ```

  6. Nahraďte metodu při zobrazení následujícím kódem:

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

    Tento kód zajistí, že data se po ověření aktualizují jenom ze služby.

  7. Přidejte následující obslužnou rutinu pro událost Click do třídy 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);
 }
 ```

  8. Uložte změny a znovu sestavte projekt přenositelné knihovny tříd, který neověřuje žádné chyby.

Přidání ověřování do aplikace pro Android

V této části se dozvíte, jak implementovat rozhraní IAuthenticate v projektu aplikace pro Android. Pokud zařízení s Androidem nepodporujete, přeskočte tuto část.

  1. v Visual Studio nebo Xamarin Studio klikněte pravým tlačítkem na projekt droid a pak nastavte jako spouštěcí Project.

  2. Stisknutím klávesy F5 spusťte projekt v ladicím programu a pak ověřte, že po spuštění aplikace je vyvolána neošetřená výjimka se stavovým kódem 401 (Neautorizováno). Kód 401 se vytvoří, protože přístup k back-endu je omezený jenom na autorizované uživatele.

  3. Otevřete MainActivity. cs v projektu pro Android a přidejte následující using příkazy:

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

  4. Aktualizujte třídu MainActivity pro implementaci rozhraní IAuthenticate následujícím způsobem:

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

  5. Aktualizujte třídu MainActivity přidáním pole MobileServiceUser a metody ověřování , která je požadována rozhraním IAuthenticate , následovně:

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

    Pokud používáte jiného poskytovatele identity než Facebook, vyberte pro MobileServiceAuthenticationProviderjinou hodnotu.

  6. Aktualizujte soubor AndroidManifest.xml přidáním následujícího kódu XML do <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>

    Nahraďte {url_scheme_of_your_app} vaším schématem URL.

  7. Do metody Create třídy MainActivity přidejte následující kód před voláním LoadApplication() :

     ```csharp
 // Initialize the authenticator before loading the app.
 App.Init((IAuthenticate)this);
 ```

    Tento kód zajišťuje inicializaci ověřovatele před tím, než se aplikace načte.

  8. Znovu sestavte aplikaci, spusťte ji a pak se přihlaste pomocí poskytovatele ověřování, kterého jste zvolili, a ověřte, že máte přístup k datům jako ověřený uživatel.

Řešení potíží

V aplikaci došlo k chybě. Java.Lang.NoSuchMethodError: No static method startActivity

V některých případech jsou konflikty v balíčcích pro podporu zobrazeny jako upozornění v aplikaci Visual Studio, ale aplikace při běhu selže s touto výjimkou. V takovém případě je nutné se ujistit, že všechny balíčky podpory, na které se odkazuje v projektu, mají stejnou verzi. Balíček NuGet pro mobilní aplikace AzuremáXamarin.Android.Support.CustomTabszávislost pro platformu Android, takže pokud váš projekt používá novější balíčky podpory, je nutné nainstalovat přímo tento balíček s požadovanou verzi, aby nedocházelo ke konfliktům.

Přidání ověřování do aplikace pro iOS

V této části se dozvíte, jak implementovat rozhraní IAuthenticate v projektu aplikace pro iOS. Pokud nepodporujete zařízení s iOS, přeskočte tuto část.

  1. V Visual Studio nebo Xamarin Studio klikněte pravým tlačítkem na projekt pro iOS a pak klikněte na Nastavit jako Project.

  2. Stisknutím klávesy F5 spusťte projekt v ladicím programu a potom ověřte, že se po spuštění aplikace vyvolala neošetřená výjimka se stavový kódem 401 (Neautorizované). Odpověď 401 se vyprodukují, protože přístup k back-endu je omezený jenom na oprávněné uživatele.

  3. Otevřete AppDelegate.cs v projektu pro iOS a přidejte následující using příkazy:

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

  4. Aktualizujte třídu AppDelegate tak, aby implementujte rozhraní IAuthenticate následujícím způsobem:

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

  5. Následujícím způsobem aktualizujte třídu AppDelegate přidáním pole MobileServiceUser a metody Authenticate , které vyžaduje rozhraní IAuthenticate :

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

    Pokud používáte jiného zprostředkovatele identity než Facebook, zvolte jinou hodnotu pro [MobileServiceAuthenticationProvider].

  6. Aktualizujte třídu AppDelegate přidáním přetížení metody OpenUrl následujícím způsobem:

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

  7. Do metody FinishedLaunching přidejte následující řádek kódu před volání LoadApplication()metody :

     ```csharp
 App.Init(this);
 ```

    Tento kód zajistí inicializaci authenticatoru před načtením aplikace.

  8. Otevřete soubor Info.plist a přidejte typ adresy URL. Nastavte Identifikátor na název podle vašeho výběru, Schémata adres URL na schéma adresy URL pro vaši aplikaci a Role na Žádné.

  9. Znovu sestavte aplikaci, spusťte ji, přihlaste se pomocí zprostředkovatele ověřování, který jste zvolili, a ověřte, že máte přístup k datům jako ověřený uživatel.

Přidání ověřování do Windows 10 (včetně Telefon) projektů aplikací

Tato část ukazuje, jak implementovat rozhraní IAuthenticate v projektech Windows 10 aplikací. Stejný postup platí pro projekty Univerzální platforma Windows (UPW), ale pomocí projektu UPW (se změnami). Tuto část přeskočte, pokud zařízení Windows podporujete.

  1. V Visual Studio klikněte pravým tlačítkem na projekt UPW a pak klikněte na Nastavit jako Project.

  2. Stisknutím klávesy F5 spusťte projekt v ladicím programu a potom ověřte, že se po spuštění aplikace vyvolala neošetřená výjimka se stavový kódem 401 (Neautorizované). K odpovědi 401 dochází, protože přístup na back-endu je omezený jenom na oprávněné uživatele.

  3. Otevřete soubor MainPage.xaml.cs pro Windows aplikace a přidejte následující using příkazy:

     ```csharp
 using Microsoft.WindowsAzure.MobileServices;
 using System.Threading.Tasks;
 using Windows.UI.Popups;
 using <your_Portable_Class_Library_namespace>;
 ```

    Nahraďte <your_Portable_Class_Library_namespace> oborem názvů pro přenosnou knihovnu tříd.

  4. Aktualizujte třídu MainPage a implementujte rozhraní IAuthenticate následujícím způsobem:

     public sealed partial class MainPage : IAuthenticate

  5. Aktualizujte třídu MainPage přidáním pole MobileServiceUser a metody Authenticate , které vyžaduje rozhraní IAuthenticate , následujícím způsobem:

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

    Pokud používáte jiného zprostředkovatele identity než Facebook, zvolte pro MobileServiceAuthenticationProvider jinou hodnotu.

  6. Do konstruktoru pro třídu MainPage před volání přidejte následující řádek kódu LoadApplication():

     ```csharp
 // Initialize the authenticator before loading the app.
 <your_Portable_Class_Library_namespace>.App.Init(this);
 ```

    Nahraďte <your_Portable_Class_Library_namespace> oborem názvů pro přenosnou knihovnu tříd.

  7. Pokud používáte UPW, přidejte do třídy App následující přepsání metody OnActivated:

     ```csharp
 protected override void OnActivated(IActivatedEventArgs args)
 {
    base.OnActivated(args);

     if (args.Kind == ActivationKind.Protocol)
     {
         ProtocolActivatedEventArgs protocolArgs = args as ProtocolActivatedEventArgs;
         MobileServiceClientExtensions.ResumeWithURL(TodoItemManager.DefaultManager.CurrentClient,protocolArgs.Uri);
     }
 }
 ```

  8. Otevřete Package.appxmanifest a přidejte deklaraci protokolu. Nastavte Zobrazovaný název na název podle vašeho výběru a Název na schéma adresy URL pro vaši aplikaci.

  9. Znovu sestavte aplikaci, spusťte ji, přihlaste se pomocí zprostředkovatele ověřování, který jste zvolili, a ověřte, že máte přístup k datům jako ověřený uživatel.

Další kroky

Teď, když jste dokončili tento kurz základního ověřování, zvažte pokračování k jednomu z následujících kurzů:

  • Přidání nabízených oznámení do aplikace

    Naučte se přidávat do aplikace podporu nabízených oznámení a konfigurovat back-end mobilní aplikace tak, aby k zasílání nabízených oznámení používal Azure Notification Hubs.

  • Povolení offline synchronizace u aplikace

    Naučte se, jak pomocí back-endu mobilní aplikace přidat do aplikace podporu offline režimu. Offline synchronizace umožňuje koncovým uživatelům pracovat s mobilní aplikací – prohlížení, přidávání nebo úpravy dat – i když není k dispozici žádné síťové připojení.