Come usare la libreria client iOS per le app mobili di AzureHow to Use iOS Client Library for Azure Mobile Apps

Questa guida descrive come eseguire scenari comuni usando il più recente SDK per iOS per le app per dispositivi mobili di Azure.This guide teaches you to perform common scenarios using the latest Azure Mobile Apps iOS SDK. Se si ha familiarità con le App per dispositivi mobili di Azure, completare innanzitutto Azure Mobile App Quick Start per creare un back-end, creare una tabella e scaricare un progetto Xcode iOS preesistente.If you are new to Azure Mobile Apps, first complete [Azure Mobile Apps Quick Start] to create a backend, create a table, and download a pre-built iOS Xcode project. In questa Guida, l'attenzione è posta sul lato client iOS SDK.In this guide, we focus on the client-side iOS SDK. Per altre informazioni sull'SDK sul lato server per il back-end, vedere le procedure per l'SDK del server.To learn more about the server-side SDK for the backend, see the Server SDK HOWTOs.

Documentazione di riferimentoReference documentation

La documentazione di riferimento per il client SDK per iOS è disponibile qui: Riferimento al Client iOS di App per dispositivi mobili di Azure.The reference documentation for the iOS client SDK is located here: Azure Mobile Apps iOS Client Reference.

Piattaforme supportateSupported Platforms

L'SDK di iOS supporta progetti Objective-C, Swift 2.2 e Swift 2.3 per le versioni iOS 8.0 o successive.The iOS SDK supports Objective-C projects, Swift 2.2 projects, and Swift 2.3 projects for iOS versions 8.0 or later.

L'autenticazione "flusso server" usa una visualizzazione Web per l'interfaccia utente presentata.The "server-flow" authentication uses a WebView for the presented UI. Se il dispositivo non è in grado di presentare un'interfaccia utente con visualizzazione Web, è necessario un altro metodo di autenticazione non incluso nell'ambito del prodotto.If the device is not able to present a WebView UI, then another method of authentication is required that is outside the scope of the product.
Questo SDK non è quindi adatto per i dispositivi di tipo controllo o con restrizioni simili.This SDK is thus not suitable for Watch-type or similarly restricted devices.

Installazione e prerequisitiSetup and Prerequisites

In questa guida si presuppone che siano stati creati un backend e una tabella.This guide assumes that you have created a backend with a table. In questa guida si presuppone che la tabella abbia lo stesso schema delle tabelle presenti in tali esercitazioni.This guide assumes that the table has the same schema as the tables in those tutorials. In questa guida si presuppone inoltre che nel codice, si faccia riferimento a MicrosoftAzureMobile.framework e si importi MicrosoftAzureMobile/MicrosoftAzureMobile.h.This guide also assumes that in your code, you reference MicrosoftAzureMobile.framework and import MicrosoftAzureMobile/MicrosoftAzureMobile.h.

Procedura: creare ClientHow to: Create Client

Per accedere a un back-end di applicazioni per dispositivi mobili di Azure nel progetto, creare un MSClient.To access an Azure Mobile Apps backend in your project, create an MSClient. Sostituire AppUrl con l'URL dell'app.Replace AppUrl with the app URL. È possibile lasciare gatewayURLString e applicationKey vuoti.You may leave gatewayURLString and applicationKey empty. Se si configura un gateway per l'autenticazione, popolare gatewayURLString con l'URL del gateway.If you set up a gateway for authentication, populate gatewayURLString with the gateway URL.

Objective-C:Objective-C:

MSClient *client = [MSClient clientWithApplicationURLString:@"AppUrl"];

Swift:Swift:

let client = MSClient(applicationURLString: "AppUrl")

Procedura: Creare un riferimento alla tabellaHow to: Create Table Reference

Per l'accesso o l'aggiornamento dei dati, creare un riferimento alla tabella di back-end.To access or update data, create a reference to the backend table. Sostituire TodoItem con il nome della tabellaReplace TodoItem with the name of your table

Objective-C:Objective-C:

MSTable *table = [client tableWithName:@"TodoItem"];

Swift:Swift:

let table = client.tableWithName("TodoItem")

Procedura: Eseguire query sui datiHow to: Query Data

Per creare una query di database, eseguire una query sull'oggetto MSTable .To create a database query, query the MSTable object. La query seguente ottiene tutti gli elementi in TodoItem e registra il testo di ciascun elemento.The following query gets all the items in TodoItem and logs the text of each item.

Objective-C:Objective-C:

[table readWithCompletion:^(MSQueryResult *result, NSError *error) {
        if(error) { // error is nil if no error occured
                NSLog(@"ERROR %@", error);
        } else {
                for(NSDictionary *item in result.items) { // items is NSArray of records that match query
                        NSLog(@"Todo Item: %@", [item objectForKey:@"text"]);
                }
        }
}];

Swift:Swift:

table.readWithCompletion { (result, error) in
    if let err = error {
        print("ERROR ", err)
    } else if let items = result?.items {
        for item in items {
            print("Todo Item: ", item["text"])
        }
    }
}

Procedura: Filtrare i dati restituitiHow to: Filter Returned Data

Per filtrare i risultati sono disponibili numerose opzioni.To filter results, there are many available options.

Per filtrare tramite un predicato, usare NSPredicate e readWithPredicate.To filter using a predicate, use an NSPredicate and readWithPredicate. I filtri seguenti hanno restituito i dati per trovare solo gli elementi Todo incompleti.The following filters returned data to find only incomplete Todo items.

Objective-C:Objective-C:

// Create a predicate that finds items where complete is false
NSPredicate * predicate = [NSPredicate predicateWithFormat:@"complete == NO"];
// Query the TodoItem table
[table readWithPredicate:predicate completion:^(MSQueryResult *result, NSError *error) {
        if(error) {
                NSLog(@"ERROR %@", error);
        } else {
                for(NSDictionary *item in result.items) {
                        NSLog(@"Todo Item: %@", [item objectForKey:@"text"]);
                }
        }
}];

Swift:Swift:

// Create a predicate that finds items where complete is false
let predicate =  NSPredicate(format: "complete == NO")
// Query the TodoItem table
table.readWithPredicate(predicate) { (result, error) in
    if let err = error {
        print("ERROR ", err)
    } else if let items = result?.items {
        for item in items {
            print("Todo Item: ", item["text"])
        }
    }
}

Procedura: Usare MSQueryHow to: Use MSQuery

Per eseguire una query complessa che includa l'ordinamento e il paging, creare un oggetto MSQuery , direttamente o tramite un predicato:To perform a complex query (including sorting and paging), create an MSQuery object, directly or by using a predicate:

Objective-C:Objective-C:

MSQuery *query = [table query];
MSQuery *query = [table queryWithPredicate: [NSPredicate predicateWithFormat:@"complete == NO"]];

Swift:Swift:

let query = table.query()
let query = table.queryWithPredicate(NSPredicate(format: "complete == NO"))

MSQuery consente di controllare diversi comportamenti di query.MSQuery lets you control several query behaviors.

  • Specificare l'ordine dei risultatiSpecify order of results
  • Limitare i campi da restituireLimit which fields to return
  • Limitare il numero di record da restituireLimit how many records to return
  • Specificare il conteggio totale nella rispostaSpecify total count in response
  • Specificare i parametri della stringa di query personalizzata nella richiestaSpecify custom query string parameters in request
  • Applicare funzioni aggiuntiveApply additional functions

Eseguire una query MSQuery chiamando readWithCompletion sull'oggetto.Execute an MSQuery query by calling readWithCompletion on the object.

Procedura: Ordinare i dati con MSQueryHow to: Sort Data with MSQuery

Per ordinare i risultati, verrà ora esaminato un esempio.To sort results, let's look at an example. Per ordinare il campo "text" in ordine crescente, quindi "complete" in ordine decrescente, richiamare MSQuery nel modo seguente:To sort by field 'text' ascending, then by 'complete' descending, invoke MSQuery like so:

Objective-C:Objective-C:

[query orderByAscending:@"text"];
[query orderByDescending:@"complete"];
[query readWithCompletion:^(MSQueryResult *result, NSError *error) {
        if(error) {
                NSLog(@"ERROR %@", error);
        } else {
                for(NSDictionary *item in result.items) {
                        NSLog(@"Todo Item: %@", [item objectForKey:@"text"]);
                }
        }
}];

Swift:Swift:

query.orderByAscending("text")
query.orderByDescending("complete")
query.readWithCompletion { (result, error) in
    if let err = error {
        print("ERROR ", err)
    } else if let items = result?.items {
        for item in items {
            print("Todo Item: ", item["text"])
        }
    }
}

Procedura: Limitare i campi ed espandere i parametri di query di tipo stringa con MSQueryHow to: Limit Fields and Expand Query String Parameters with MSQuery

Per limitare i campi da restituire in una query, specificare i nomi dei campi nella proprietà selectFields .To limit fields to be returned in a query, specify the names of the fields in the selectFields property. Questo esempio restituisce solo i campi text e completed:This example returns only the text and completed fields:

Objective-C:Objective-C:

query.selectFields = @[@"text", @"complete"];

Swift:Swift:

query.selectFields = ["text", "complete"]

Per includere parametri di query di tipo stringa aggiuntivi nella richiesta server, poiché ad esempio sono usati da uno script sul lato server personalizzato, è possibile popolare query.parameters come segue:To include additional query string parameters in the server request (for example, because a custom server-side script uses them), populate query.parameters like so:

Objective-C:Objective-C:

query.parameters = @{
    @"myKey1" : @"value1",
    @"myKey2" : @"value2",
};

Swift:Swift:

query.parameters = ["myKey1": "value1", "myKey2": "value2"]

Procedura: Configurare la dimensione di paginaHow to: Configure Page Size

Con App per dispositivi mobili di Azure la dimensione di pagina controlla il numero di record che vengono estratti contemporaneamente dalle tabelle di back-end.With Azure Mobile Apps, the page size controls the number of records that are pulled at a time from the backend tables. Una chiamata per eseguire il pull dei dati eseguirà il batch sui dati, in base alla dimensione di pagina, fino a quando non ci sono più record da estrarre.A call to pull data would then batch up data, based on this page size, until there are no more records to pull.

È possibile configurare la dimensione di pagina mediante MSPullSettings come illustrato di seguito.It's possible to configure a page size using MSPullSettings as shown below. La dimensione di pagina predefinita è 50 e l'esempio seguente la cambia in 3.The default page size is 50, and the example below changes it to 3.

È possibile configurare una dimensione di pagina diversa per finalità di prestazioni.You could configure a different page size for performance reasons. Se si dispone di un numero elevato di record di dati di piccole dimensioni, una dimensione di pagina elevata riduce il numero di round trip al server.If you have a large number of small data records, a high page size reduces the number of server round-trips.

Questa impostazione controlla la dimensione di pagina solo sul lato client.This setting controls only the page size on the client side. Se il client richiede una pagina più grande di quella supportata dal back-end di App per dispositivi mobili, la dimensione di pagina è limitata al massimo valore che il back-end può supportare.If the client asks for a larger page size than the Mobile Apps backend supports, the page size is capped at the maximum the backend is configured to support.

Questa impostazione è inoltre il numero dei record dei dati, e non la dimensione in byte.This setting is also the number of data records, not the byte size.

Se si aumenta la dimensione di pagina del client, è necessario aumentare anche la dimensione di pagina sul server.If you increase the client page size, you should also increase the page size on the server. Per la procedura da eseguire, vedere "Procedura: Modificare le dimensioni di pagina delle tabelle".See "How to: Adjust the table paging size" for the steps to do this.

Objective-C:Objective-C:

  MSPullSettings *pullSettings = [[MSPullSettings alloc] initWithPageSize:3];
  [table  pullWithQuery:query queryId:@nil settings:pullSettings
                        completion:^(NSError * _Nullable error) {
                               if(error) {
                    NSLog(@"ERROR %@", error);
                }
                           }];

Swift:Swift:

let pullSettings = MSPullSettings(pageSize: 3)
table.pullWithQuery(query, queryId:nil, settings: pullSettings) { (error) in
    if let err = error {
        print("ERROR ", err)
    }
}

Procedura: Inserire datiHow to: Insert Data

Per inserire una nuova riga di tabella, creare un elemento NSDictionary e richiamare table insert.To insert a new table row, create a NSDictionary and invoke table insert. Se Schema dinamico è abilitato, il back-end per dispositivi mobili del Servizio app di Azure genera automaticamente nuove colonne in base a NSDictionary.If [Dynamic Schema] is enabled, the Azure App Service mobile backend automatically generates new columns based on the NSDictionary.

Se non viene specificato il valore id , il back-end genera automaticamente un nuovo ID univoco.If id is not provided, the backend automatically generates a new unique ID. Specificare il proprio id per usare indirizzi e-mail, nomi utente o valori personalizzati come ID.Provide your own id to use email addresses, usernames, or your own custom values as ID. La specifica del proprio ID può semplificare l'esecuzione di join e la logica dei database aziendali.Providing your own ID may ease joins and business-oriented database logic.

result contiene il nuovo elemento inserito.The result contains the new item that was inserted. A seconda della logica del server, può includere dati aggiuntivi o modificati rispetto a quelli passati al server.Depending on your server logic, it may have additional or modified data compared to what was passed to the server.

Objective-C:Objective-C:

NSDictionary *newItem = @{@"id": @"custom-id", @"text": @"my new item", @"complete" : @NO};
[table insert:newItem completion:^(NSDictionary *result, NSError *error) {
    if(error) {
        NSLog(@"ERROR %@", error);
    } else {
        NSLog(@"Todo Item: %@", [result objectForKey:@"text"]);
    }
}];

Swift:Swift:

let newItem = ["id": "custom-id", "text": "my new item", "complete": false]
table.insert(newItem) { (result, error) in
    if let err = error {
        print("ERROR ", err)
    } else if let item = result {
        print("Todo Item: ", item["text"])
    }
}

Procedura: Modificare datiHow to: Modify Data

Per aggiornare una riga esistente, modificare un elemento e chiamare update:To update an existing row, modify an item and call update:

Objective-C:Objective-C:

NSMutableDictionary *newItem = [oldItem mutableCopy]; // oldItem is NSDictionary
[newItem setValue:@"Updated text" forKey:@"text"];
[table update:newItem completion:^(NSDictionary *result, NSError *error) {
    if(error) {
        NSLog(@"ERROR %@", error);
    } else {
        NSLog(@"Todo Item: %@", [result objectForKey:@"text"]);
    }
}];

Swift:Swift:

if let newItem = oldItem.mutableCopy() as? NSMutableDictionary {
    newItem["text"] = "Updated text"
    table2.update(newItem as [NSObject: AnyObject], completion: { (result, error) -> Void in
        if let err = error {
            print("ERROR ", err)
        } else if let item = result {
            print("Todo Item: ", item["text"])
        }
    })
}

In alternativa, fornire l'ID di riga e il campo aggiornato:Alternatively, supply the row ID and the updated field:

Objective-C:Objective-C:

[table update:@{@"id":@"custom-id", @"text":"my EDITED item"} completion:^(NSDictionary *result, NSError *error) {
    if(error) {
        NSLog(@"ERROR %@", error);
    } else {
        NSLog(@"Todo Item: %@", [result objectForKey:@"text"]);
    }
}];

Swift:Swift:

table.update(["id": "custom-id", "text": "my EDITED item"]) { (result, error) in
    if let err = error {
        print("ERROR ", err)
    } else if let item = result {
        print("Todo Item: ", item["text"])
    }
}

Per le operazioni di aggiornamento è necessario che sia impostato almeno l'attributo id .At minimum, the id attribute must be set when making updates.

Procedura: Eliminare datiHow to: Delete Data

Per eliminare un elemento, richiamare delete con l'elemento:To delete an item, invoke delete with the item:

Objective-C:Objective-C:

[table delete:item completion:^(id itemId, NSError *error) {
    if(error) {
        NSLog(@"ERROR %@", error);
    } else {
        NSLog(@"Todo Item ID: %@", itemId);
    }
}];

Swift:Swift:

table.delete(newItem as [NSObject: AnyObject]) { (itemId, error) in
    if let err = error {
        print("ERROR ", err)
    } else {
        print("Todo Item ID: ", itemId)
    }
}

In alternativa, eliminarlo specificando un ID di riga:Alternatively, delete by providing a row ID:

Objective-C:Objective-C:

[table deleteWithId:@"37BBF396-11F0-4B39-85C8-B319C729AF6D" completion:^(id itemId, NSError *error) {
    if(error) {
        NSLog(@"ERROR %@", error);
    } else {
        NSLog(@"Todo Item ID: %@", itemId);
    }
}];

Swift:Swift:

table.deleteWithId("37BBF396-11F0-4B39-85C8-B319C729AF6D") { (itemId, error) in
    if let err = error {
        print("ERROR ", err)
    } else {
        print("Todo Item ID: ", itemId)
    }
}

Per le operazioni di eliminazione, è necessario che sia impostato almeno l'attributo id .At minimum, the id attribute must be set when making deletes.

Procedura: Chiamare un'API personalizzataHow to: Call Custom API

Con un'API personalizzata è possibile esporre qualsiasi funzionalità di back-end.With a custom API, you can expose any backend functionality. Non occorre eseguire il mapping a un'operazione su tabella.It doesn't have to map to a table operation. In questo modo, non solo si ottiene maggiore controllo sulla messaggistica, ma è anche possibile leggere o impostare le intestazioni e modificare il formato del corpo della risposta.Not only do you gain more control over messaging, you can even read/set headers and change the response body format. Per informazioni su come creare un'API personalizzata nel back-end, leggere API personalizzateTo learn how to create a custom API on the backend, read Custom APIs

Per chiamare un'API personalizzata, chiamare MSClient.invokeAPI.To call a custom API, call MSClient.invokeAPI. Il contenuto della richiesta e della risposta è in formato JSON.The request and response content are treated as JSON. Per utilizzare altri tipi di supporto, usare l'altro overload di invokeAPI.To use other media types, use the other overload of invokeAPI. Per eseguire una richiesta GET invece di una richiesta POST, impostare il parametro HTTPMethod su "GET" e il parametro body su nil (dal momento che le richieste GET non hanno corpi dei messaggi). Se l'API personalizzata supporta altri verbi HTTP, modificare HTTPMethod in modo appropriato.To make a GET request instead of a POST request, set parameter HTTPMethod to "GET" and parameter body to nil (since GET requests do not have message bodies.) If your custom API supports other HTTP verbs, change HTTPMethod appropriately.

Objective-C:Objective-C:

[self.client invokeAPI:@"sendEmail"
                  body:@{ @"contents": @"Hello world!" }
            HTTPMethod:@"POST"
            parameters:@{ @"to": @"bill@contoso.com", @"subject" : @"Hi!" }
               headers:nil
            completion: ^(NSData *result, NSHTTPURLResponse *response, NSError *error) {
                if(error) {
                    NSLog(@"ERROR %@", error);
                } else {
                    // Do something with result
                }
            }];

Swift:Swift:

client.invokeAPI("sendEmail",
            body: [ "contents": "Hello World" ],
            HTTPMethod: "POST",
            parameters: [ "to": "bill@contoso.com", "subject" : "Hi!" ],
            headers: nil)
            {
                (result, response, error) -> Void in
                if let err = error {
                    print("ERROR ", err)
                } else if let res = result {
                          // Do something with result
                }
        }

Procedura: registrare modelli push per inviare notifiche multipiattaformaHow to: Register push templates to send cross-platform notifications

Per registrare i modelli, passare modelli con il metodo client.push registerDeviceToken nell'app client.To register templates, pass templates with your client.push registerDeviceToken method in your client app.

Objective-C:Objective-C:

[client.push registerDeviceToken:deviceToken template:iOSTemplate completion:^(NSError *error) {
    if(error) {
        NSLog(@"ERROR %@", error);
    }
}];

Swift:Swift:

    client.push?.registerDeviceToken(NSData(), template: iOSTemplate, completion: { (error) in
        if let err = error {
            print("ERROR ", err)
        }
    })

I modelli sono di tipo NSDictionary e possono contenere più modelli nel formato seguente:Your templates are of type NSDictionary and can contain multiple templates in the following format:

Objective-C:Objective-C:

NSDictionary *iOSTemplate = @{ @"templateName": @{ @"body": @{ @"aps": @{ @"alert": @"$(message)" } } } };

Swift:Swift:

let iOSTemplate = ["templateName": ["body": ["aps": ["alert": "$(message)"]]]]

Tutti i tag vengono rimossi dalla richiesta per motivi di sicurezza.All tags are stripped from the request for security. Per aggiungere tag alle istallazione o ai modelli all'interno delle istallazioni, vedere Usare l'SDK del server back-end .NET per App per dispositivi mobili di Azure.To add tags to installations or templates within installations, see Work with the .NET backend server SDK for Azure Mobile Apps. Per inviare notifiche tramite questi modelli registrati, usare le API di Hub di notifica.To send notifications using these registered templates, work with Notification Hubs APIs.

Procedura: Gestire gli erroriHow to: Handle Errors

Quando viene eseguita una chiamata a un back-end per dispositivi mobili del Servizio app di Azure, il blocco di completamento contiene un parametro NSError .When you call an Azure App Service mobile backend, the completion block contains an NSError parameter. Quando si verifica un errore, il parametro sarà diverso da Nil.When an error occurs, this parameter is non-nil. In questo caso, è necessario verificare il parametro nel codice e gestire l'errore nel modo appropriato, come dimostrato nei frammenti di codice precedenti.In your code, you should check this parameter and handle the error as needed, as demonstrated in the preceding code snippets.

Il file <WindowsAzureMobileServices/MSError.h> definisce le costanti MSErrorResponseKey, MSErrorRequestKey e MSErrorServerItemKey.The file <WindowsAzureMobileServices/MSError.h> defines the constants MSErrorResponseKey, MSErrorRequestKey, and MSErrorServerItemKey. Per ottenere più dati relativi all'errore:To get more data related to the error:

Objective-C:Objective-C:

NSDictionary *serverItem = [error.userInfo objectForKey:MSErrorServerItemKey];

Swift:Swift:

let serverItem = error.userInfo[MSErrorServerItemKey]

Il file definisce anche le costanti per ogni codice di errore:In addition, the file defines constants for each error code:

Objective-C:Objective-C:

if (error.code == MSErrorPreconditionFailed) {

Swift:Swift:

if (error.code == MSErrorPreconditionFailed) {

Procedura: Autenticare gli utenti con Active Directory Authentication LibraryHow to: Authenticate users with the Active Directory Authentication Library

È possibile usare Active Directory Authentication Library (ADAL) per far accedere gli utenti all'applicazione tramite Azure Active Directory.You can use the Active Directory Authentication Library (ADAL) to sign users into your application using Azure Active Directory. È preferibile usare l'autenticazione del flusso client tramite un SDK del provider di identità anziché il metodo loginWithProvider:completion: .Client flow authentication using an identity provider SDK is preferable to using the loginWithProvider:completion: method. L'autenticazione del flusso client garantisce un'esperienza utente più naturale e consente una maggiore personalizzazione.Client flow authentication provides a more native UX feel and allows for additional customization.

  1. Configurare il back-end dell'app per dispositivi mobili per l'accesso ad Azure Active Directory seguendo l'esercitazione Come configurare un'applicazione del servizio app per usare l'account di accesso di Azure Active Directory.Configure your mobile app backend for AAD sign-in by following the How to configure App Service for Active Directory login tutorial. Assicurarsi di completare il passaggio facoltativo di registrazione di un'applicazione client nativa.Make sure to complete the optional step of registering a native client application. Per iOS è consigliabile che l'URI di reindirizzamento sia nel formato <app-scheme>://<bundle-id>.For iOS, we recommend that the redirect URI is of the form <app-scheme>://<bundle-id>. Per altre informazioni, vedere Guida introduttiva di ADAL iOS.For more information, see the ADAL iOS quickstart.
  2. Installare ADAL usando Cocoapods.Install ADAL using Cocoapods. Modificare il podfile includendo la definizione seguente e sostituendo YOUR-PROJECT con il nome del progetto Xcode:Edit your Podfile to include the following definition, replacing YOUR-PROJECT with the name of your Xcode project:

     source 'https://github.com/CocoaPods/Specs.git'
     link_with ['YOUR-PROJECT']
     xcodeproj 'YOUR-PROJECT'
    

    e il Pod:and the Pod:

     pod 'ADALiOS'
    
  3. Nel terminale eseguire pod install dalla directory contenente il progetto e quindi aprire l'area di lavoro di Xcode generata (non il progetto).Using the Terminal, run pod install from the directory containing your project, and then open the generated Xcode workspace (not the project).
  4. Aggiungere il codice seguente all'applicazione, in base al linguaggio usato.Add the following code to your application, according to the language you are using. In ogni esempio eseguire queste sostituzioni:In each, make these replacements:

    • Sostituire INSERT-AUTHORITY-HERE con il nome del tenant in cui è stato eseguito il provisioning dell'applicazione.Replace INSERT-AUTHORITY-HERE with the name of the tenant in which you provisioned your application. Il formato deve essere https://login.microsoftonline.com/contoso.onmicrosoft.com. È possibile copiare questo valore dalla scheda Dominio di Azure Active Directory nel portale di Azure.The format should be https://login.microsoftonline.com/contoso.onmicrosoft.com. This value can be copied from the Domain tab in your Azure Active Directory in the [Azure portal].
    • Sostituire INSERT-RESOURCE-ID-HERE con l'ID client per il back-end dell'app per dispositivi mobili.Replace INSERT-RESOURCE-ID-HERE with the client ID for your mobile app backend. L'ID client è disponibile nella scheda Avanzate in Impostazioni di Azure Active Directory nel portale.You can obtain the client ID from the Advanced tab under Azure Active Directory Settings in the portal.
    • Sostituire INSERT-CLIENT-ID-HERE con l'ID client copiato dall'applicazione client nativa.Replace INSERT-CLIENT-ID-HERE with the client ID you copied from the native client application.
    • Sostituire INSERT-REDIRECT-URI-HERE con l'endpoint /.auth/login/done del sito, usando lo schema HTTPS.Replace INSERT-REDIRECT-URI-HERE with your site's /.auth/login/done endpoint, using the HTTPS scheme. Questo valore deve essere simile a https://contoso.azurewebsites.net/.auth/login/done.This value should be similar to https://contoso.azurewebsites.net/.auth/login/done.

Objective-C:Objective-C:

#import <ADALiOS/ADAuthenticationContext.h>
#import <ADALiOS/ADAuthenticationSettings.h>
// ...
- (void) authenticate:(UIViewController*) parent
           completion:(void (^) (MSUser*, NSError*))completionBlock;
{
    NSString *authority = @"INSERT-AUTHORITY-HERE";
    NSString *resourceId = @"INSERT-RESOURCE-ID-HERE";
    NSString *clientId = @"INSERT-CLIENT-ID-HERE";
    NSURL *redirectUri = [[NSURL alloc]initWithString:@"INSERT-REDIRECT-URI-HERE"];
    ADAuthenticationError *error;
    ADAuthenticationContext *authContext = [ADAuthenticationContext authenticationContextWithAuthority:authority error:&error];
    authContext.parentController = parent;
    [ADAuthenticationSettings sharedInstance].enableFullScreen = YES;
    [authContext acquireTokenWithResource:resourceId
                                 clientId:clientId
                              redirectUri:redirectUri
                          completionBlock:^(ADAuthenticationResult *result) {
                              if (result.status != AD_SUCCEEDED)
                              {
                                  completionBlock(nil, result.error);;
                              }
                              else
                              {
                                  NSDictionary *payload = @{
                                                            @"access_token" : result.tokenCacheStoreItem.accessToken
                                                            };
                                  [client loginWithProvider:@"aad" token:payload completion:completionBlock];
                              }
                          }];
}

Swift:Swift:

// add the following imports to your bridging header:
//        #import <ADALiOS/ADAuthenticationContext.h>
//        #import <ADALiOS/ADAuthenticationSettings.h>

func authenticate(parent: UIViewController, completion: (MSUser?, NSError?) -> Void) {
    let authority = "INSERT-AUTHORITY-HERE"
    let resourceId = "INSERT-RESOURCE-ID-HERE"
    let clientId = "INSERT-CLIENT-ID-HERE"
    let redirectUri = NSURL(string: "INSERT-REDIRECT-URI-HERE")
    var error: AutoreleasingUnsafeMutablePointer<ADAuthenticationError?> = nil
    let authContext = ADAuthenticationContext(authority: authority, error: error)
    authContext.parentController = parent
    ADAuthenticationSettings.sharedInstance().enableFullScreen = true
    authContext.acquireTokenWithResource(resourceId, clientId: clientId, redirectUri: redirectUri) { (result) in
            if result.status != AD_SUCCEEDED {
                completion(nil, result.error)
            }
            else {
                let payload: [String: String] = ["access_token": result.tokenCacheStoreItem.accessToken]
                client.loginWithProvider("aad", token: payload, completion: completion)
            }
        }
}

Procedura: Autenticare gli utenti con Facebook SDK for iOSHow to: Authenticate users with the Facebook SDK for iOS

È possibile usare Facebook SDK for iOS per consentire l'accesso degli utenti all'applicazione tramite Facebook.You can use the Facebook SDK for iOS to sign users into your application using Facebook. È preferibile usare l'autenticazione del flusso client all'uso del metodo loginWithProvider:completion: .Using a client flow authentication is preferable to using the loginWithProvider:completion: method. L'autenticazione del flusso client garantisce un'esperienza utente più naturale e consente una maggiore personalizzazione.The client flow authentication provides a more native UX feel and allows for additional customization.

  1. Configurare il back-end dell'app per dispositivi mobili per l'accesso con l'account Facebook seguendo l'esercitazione Come configurare un'applicazione del servizio App per usare l'account di accesso di Facebook.Configure your mobile app backend for Facebook sign-in by following the How to configure App Service for Facebook login tutorial.
  2. Installare Facebook SDK for iOS secondo le indicazioni della documentazione Facebook SDK for iOS - Getting Started (Facebook SDK for iOS: guida introduttiva).Install the Facebook SDK for iOS by following the Facebook SDK for iOS - Getting Started documentation. Anziché creare un'app, è possibile aggiungere la piattaforma iOS alla procedura di registrazione esistente.Instead of creating an app, you can add the iOS platform to your existing registration.
  3. La documentazione di Facebook include codice Objective-C nel delegato dell'app.Facebook's documentation includes some Objective-C code in the App Delegate. Se si usa Swift, è possibile utilizzare le seguenti traduzioni per AppDelegate.swift:If you are using Swift, you can use the following translations for AppDelegate.swift:

     // Add the following import to your bridging header:
     //        #import <FBSDKCoreKit/FBSDKCoreKit.h>
    
     func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool {
         FBSDKApplicationDelegate.sharedInstance().application(application, didFinishLaunchingWithOptions: launchOptions)
         // Add any custom logic here.
         return true
     }
    
     func application(application: UIApplication, openURL url: NSURL, sourceApplication: String?, annotation: AnyObject?) -> Bool {
         let handled = FBSDKApplicationDelegate.sharedInstance().application(application, openURL: url, sourceApplication: sourceApplication, annotation: annotation)
         // Add any custom logic here.
         return handled
     }
    
  4. Oltre ad aggiungere FBSDKCoreKit.framework al progetto, aggiungere nello stesso modo anche un riferimento a FBSDKLoginKit.framework.In addition to adding FBSDKCoreKit.framework to your project, also add a reference to FBSDKLoginKit.framework in the same way.
  5. Aggiungere il codice seguente all'applicazione, in base al linguaggio usato.Add the following code to your application, according to the language you are using.

Objective-C:Objective-C:

#import <FBSDKLoginKit/FBSDKLoginKit.h>
#import <FBSDKCoreKit/FBSDKAccessToken.h>
// ...
- (void) authenticate:(UIViewController*) parent
           completion:(void (^) (MSUser*, NSError*)) completionBlock;
{        
    FBSDKLoginManager *loginManager = [[FBSDKLoginManager alloc] init];
    [loginManager
     logInWithReadPermissions: @[@"public_profile"]
     fromViewController:parent
     handler:^(FBSDKLoginManagerLoginResult *result, NSError *error) {
         if (error) {
             completionBlock(nil, error);
         } else if (result.isCancelled) {
             completionBlock(nil, error);
         } else {
             NSDictionary *payload = @{
                                       @"access_token":result.token.tokenString
                                       };
             [client loginWithProvider:@"facebook" token:payload completion:completionBlock];
         }
     }];
}

Swift:Swift:

// Add the following imports to your bridging header:
//        #import <FBSDKLoginKit/FBSDKLoginKit.h>
//        #import <FBSDKCoreKit/FBSDKAccessToken.h>

func authenticate(parent: UIViewController, completion: (MSUser?, NSError?) -> Void) {
    let loginManager = FBSDKLoginManager()
    loginManager.logInWithReadPermissions(["public_profile"], fromViewController: parent) { (result, error) in
        if (error != nil) {
            completion(nil, error)
        }
        else if result.isCancelled {
            completion(nil, error)
        }
        else {
            let payload: [String: String] = ["access_token": result.token.tokenString]
            client.loginWithProvider("facebook", token: payload, completion: completion)
        }
    }
}

Procedura: Autenticare gli utenti con Twitter Fabric for iOSHow to: Authenticate users with Twitter Fabric for iOS

È possibile usare Fabric for iOS per consentire l'accesso degli utenti all'applicazione tramite Twitter.You can use Fabric for iOS to sign users into your application using Twitter. L'autenticazione del flusso client è preferibile all'uso del metodo loginWithProvider:completion: , perché garantisce un'esperienza utente più naturale e consente una maggiore personalizzazione.Client Flow authentication is preferable to using the loginWithProvider:completion: method, as it provides a more native UX feel and allows for additional customization.

  1. Configurare il back-end dell'app per dispositivi mobili per l'accesso con l'account Twitter seguendo l'esercitazione Come configurare un'applicazione del servizio app per usare l'account di accesso di Twitter .Configure your mobile app backend for Twitter sign-in by following the How to configure App Service for Twitter login tutorial.
  2. Aggiungere Fabric al progetto seguendo le indicazioni della documentazione Fabric for iOS - Getting Started (Fabric for iOS: guida introduttiva) e configurando TwitterKit.Add Fabric to your project by following the Fabric for iOS - Getting Started documentation and setting up TwitterKit.

    Nota

    Per impostazione predefinita, Fabric crea automaticamente un'applicazione Twitter.By default, Fabric creates a Twitter application for you. È possibile evitare di creare un'applicazione registrando la chiave utente e il segreto utente creati in precedenza tramite i frammenti di codice seguenti.You can avoid creating an application by registering the Consumer Key and Consumer Secret you created earlier using the following code snippets. In alternativa, è possibile sostituire i valori relativi alla chiave utente e al segreto utente forniti al servizio app con i valori visualizzati nel dashboard di Fabric.Alternatively, you can replace the Consumer Key and Consumer Secret values that you provide to App Service with the values you see in the [Fabric Dashboard]. Se si sceglie questa opzione, assicurarsi di impostare l'URL di callback su un valore segnaposto, ad esempio https://<yoursitename>.azurewebsites.net/.auth/login/twitter/callback.If you choose this option, be sure to set the callback URL to a placeholder value, such as https://<yoursitename>.azurewebsites.net/.auth/login/twitter/callback.

    Se si sceglie di usare i segreti creati in precedenza, aggiungere il codice seguente al delegato dell'app:If you choose to use the secrets you created earlier, add the following code to your App Delegate:

    Objective-C:Objective-C:

     #import <Fabric/Fabric.h>
     #import <TwitterKit/TwitterKit.h>
     // ...
     - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
     {
         [[Twitter sharedInstance] startWithConsumerKey:@"your_key" consumerSecret:@"your_secret"];
         [Fabric with:@[[Twitter class]]];
         // Add any custom logic here.
         return YES;
     }
    

    Swift:Swift:

     import Fabric
     import TwitterKit
     // ...
     func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool {
         Twitter.sharedInstance().startWithConsumerKey("your_key", consumerSecret: "your_secret")
         Fabric.with([Twitter.self])
         // Add any custom logic here.
         return true
     }
    
  3. Aggiungere il codice seguente all'applicazione, in base al linguaggio usato.Add the following code to your application, according to the language you are using.

Objective-C:Objective-C:

#import <TwitterKit/TwitterKit.h>
// ...
- (void)authenticate:(UIViewController*)parent completion:(void (^) (MSUser*, NSError*))completionBlock
{
    [[Twitter sharedInstance] logInWithCompletion:^(TWTRSession *session, NSError *error) {
        if (session) {
            NSDictionary *payload = @{
                                        @"access_token":session.authToken,
                                        @"access_token_secret":session.authTokenSecret
                                    };
            [client loginWithProvider:@"twitter" token:payload completion:completionBlock];
        } else {
            completionBlock(nil, error);
        }
    }];
}

Swift:Swift:

import TwitterKit
// ...
func authenticate(parent: UIViewController, completion: (MSUser?, NSError?) -> Void) {
    let client = self.table!.client
    Twitter.sharedInstance().logInWithCompletion { session, error in
        if (session != nil) {
            let payload: [String: String] = ["access_token": session!.authToken, "access_token_secret": session!.authTokenSecret]
            client.loginWithProvider("twitter", token: payload, completion: completion)
        } else {
            completion(nil, error)
        }
    }
}

Procedura: Autenticare gli utenti con Google Sign-In SDK for iOSHow to: Authenticate users with the Google Sign-In SDK for iOS

È possibile usare Google Sign-In SDK for iOS per consentire l'accesso degli utenti all'applicazione tramite un account Google.You can use the Google Sign-In SDK for iOS to sign users into your application using a Google account. Google ha annunciato recentemente modifiche ai criteri di sicurezza di OAuth.Google recently announced changes to their OAuth security policies. Queste modifiche apportate ai criteri richiederanno l'uso di Google SDK in futuro.These policy changes will require the use of the Google SDK in the future.

  1. Configurare il back-end dell'app per dispositivi mobili per l'accesso con l'account Google seguendo l'esercitazione Come configurare un'applicazione del servizio app per usare l'account di accesso di Google .Configure your mobile app backend for Google sign-in by following the How to configure App Service for Google login tutorial.
  2. Installare Google SDK for iOS seguendo le istruzioni nel documento Start integrating Google Sign-In into your iOS app (Iniziare a integrare l'accesso di Google nell'app iOS).Install the Google SDK for iOS by following the Google Sign-In for iOS - Start integrating documentation. È possibile ignorare la sezione relativa all'autenticazione con un server di back-end.You may skip the "Authenticate with a Backend Server" section.
  3. Aggiungere quanto segue al metodo signIn:didSignInForUser:withError: di delegato, a seconda del linguaggio usato.Add the following to your delegate's signIn:didSignInForUser:withError: method, according to the language you are using.

Objective-C:Objective-C:

    NSDictionary *payload = @{
                              @"id_token":user.authentication.idToken,
                              @"authorization_code":user.serverAuthCode
                              };

    [client loginWithProvider:@"google" token:payload completion:^(MSUser *user, NSError *error) {
        // ...
    }];

Swift:Swift:

    let payload: [String: String] = ["id_token": user.authentication.idToken, "authorization_code": user.serverAuthCode]
    client.loginWithProvider("google", token: payload) { (user, error) in
        // ...
    }
  1. Aggiungere anche il codice seguente a application:didFinishLaunchingWithOptions: nel delegato dell'app, sostituendo "SERVER_CLIENT_ID" con lo stesso ID usato per configurare il servizio app nel passaggio 1.Make sure you also add the following to application:didFinishLaunchingWithOptions: in your app delegate, replacing "SERVER_CLIENT_ID" with the same ID that you used to configure App Service in step 1.

Objective-C:Objective-C:

     [GIDSignIn sharedInstance].serverClientID = @"SERVER_CLIENT_ID";

Swift:Swift:

    GIDSignIn.sharedInstance().serverClientID = "SERVER_CLIENT_ID"
  1. Aggiungere il codice seguente all'applicazione in una classe UIViewController che implementi il protocollo GIDSignInUIDelegate , in base al linguaggio usato.Add the following code to your application in a UIViewController that implements the GIDSignInUIDelegate protocol, according to the language you are using. L'utente viene disconnesso prima di accedere nuovamente e anche se non è necessario immettere le credenziali una seconda volta, verrà visualizzata una finestra di dialogo di consenso.You are signed out before being signed in again, and although you don't need to enter your credentials again, you see a consent dialog. Chiamare questo metodo solo quando il token della sessione è scaduto.Only call this method when the session token has expired.

    Objective-C:Objective-C:

    #import <Google/SignIn.h>
    // ...
    - (void)authenticate
    {
            [GIDSignIn sharedInstance].uiDelegate = self;
            [[GIDSignIn sharedInstance] signOut];
            [[GIDSignIn sharedInstance] signIn];
     }
    

    Swift:Swift:

    // ...
    func authenticate() {
        GIDSignIn.sharedInstance().uiDelegate = self
        GIDSignIn.sharedInstance().signOut()
        GIDSignIn.sharedInstance().signIn()
    }