Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Uso dell'SDK iOS generato da API Gateway per un'API REST in Objective-C o Swift
In questo tutorial mostreremo come usare un SDK iOS generato da API Gateway per un'API REST in un'app Objective-C o Swift per chiamare l'API sottostante. Useremo l'[SimpleCalc API](simple-calc-lambda-api.md) come esempio per illustrare i seguenti argomenti:
+ Come installare i componenti AWS Mobile SDK richiesti nel tuo progetto Xcode
+ Come creare l'oggetto client dell'API prima di chiamare i metodi dell'API
+ Come chiamare i metodi API attraverso i metodi SDK corrispondenti nell'oggetto client dell'API
+ Come preparare un input di metodo e analizzare il risultato utilizzando le classi di modello corrispondenti dell'SDK
**Topics**
+ [Utilizzo di un SDK iOS (Objective-C) generato per chiamare l'API](#how-to-use-sdk-ios-objc)
+ [Utilizzo di un SDK iOS (Swift) generato per chiamare l'API](#how-to-generate-sdk-ios-swift)
## Utilizzo di un SDK iOS (Objective-C) generato per chiamare l'API
Prima di iniziare la procedura seguente, è necessario completare le fasi descritte in [Genera SDKs per REST APIs in API Gateway](how-to-generate-sdk.md) per iOS in Objective-C e scaricare il file .zip dell'SDK generato.
### Installa l'SDK AWS mobile e un SDK iOS generato da API Gateway in un progetto Objective-C
La procedura seguente descrive come installare l'SDK.
**Per installare e utilizzare un SDK iOS generato da API Gateway in Objective-C**
1. Estrai il contenuto del file .zip generato da API Gateway scaricato precedentemente. Utilizzando l'[SimpleCalc API](simple-calc-lambda-api.md), potresti voler rinominare la cartella SDK decompressa con qualcosa del genere. **sdk\_objc\_simple\_calc** In questa cartella SDK sono presenti un file `README.md` e un file `Podfile`. Il file `README.md` contiene le istruzioni per installare e usare l'SDK. Questo tutorial fornisce i dettagli relativi alle istruzioni. L'installazione consente di [CocoaPods](https://cocoapods.org)importare le librerie API Gateway richieste e altri componenti AWS Mobile SDK dipendenti. Devi aggiornare il file `Podfile` per importarlo SDKs nel progetto Xcode della tua app. La cartella SDK non archiviata contiene anche una cartella `generated-src` con il codice sorgente dell'SDK generato dell'API.
1. Avvia Xcode e crea un nuovo progetto Objective-C per iOS. Prendi nota della destinazione del progetto. Dovrai specificare questa impostazione nel `Podfile`.
1. Per AWS Mobile SDK for iOS importarlo nel progetto Xcode utilizzando CocoaPods, procedi come segue:
1. Installa CocoaPods eseguendo il seguente comando in una finestra di terminale:
```
sudo gem install cocoapods
pod setup
```
1. Copia il file `Podfile` dalla cartella SDK estratta nella stessa directory in cui si trova il file di progetto Xcode. Sostituisci il blocco seguente:
```
target '{{}}' do
pod 'AWSAPIGateway', '~> 2.4.7'
end
```
con il nome di destinazione del progetto:
```
target '{{app_objc_simple_calc}}' do
pod 'AWSAPIGateway', '~> 2.4.7'
end
```
Se il progetto Xcode già contiene un file denominato `Podfile`, aggiungi la riga di codice seguente:
```
pod 'AWSAPIGateway', '~> 2.4.7'
```
1. Apri una finestra del terminale ed esegui il comando seguente:
```
pod install
```
Questo installa il componente API Gateway e altri componenti AWS Mobile SDK dipendenti.
1. Chiudi il progetto Xcode e apri il file `.xcworkspace` per riavviare Xcode.
1. Aggiungi tutti i file `.h` e `.m` dalla directory `generated-src` estratta dell'SDK nel progetto Xcode.
*Per importare AWS Mobile SDK for iOS Objective-C nel tuo progetto scaricando esplicitamente AWS Mobile SDK o utilizzando [Carthage](https://github.com/Carthage/Carthage#installing-carthage), segui le istruzioni nel file README.md.* Assicurati di utilizzare solo una di queste opzioni per importare Mobile SDK. AWS
### Chiamata ai metodi API mediante l'SDK iOS generato da API Gateway in un progetto Objective-C
Quando avete generato l'SDK con il prefisso di `SIMPLE_CALC` for questa [SimpleCalc API](simple-calc-lambda-api.md) con due modelli per l'input (`Input`) e l'output (`Result`) dei metodi, nell'SDK, la classe client API risultante diventa `SIMPLE_CALCSimpleCalcClient` e le classi di dati corrispondenti sono `SIMPLE_CALCInput` e, rispettivamente. `SIMPLE_CALCResult` Le richieste e le risposte API sono mappate ai metodi SDK come segue:
+ La richiesta API di
```
GET /?a=...&b=...&op=...
```
diventa il metodo SDK di
```
(AWSTask *)rootGet:(NSString *)op a:(NSString *)a b:(NSString *)b
```
La proprietà `AWSTask.result` è del tipo `SIMPLE_CALCResult`, se il modello `Result` è stato aggiunto alla risposta del metodo. In caso contrario, è del tipo `NSDictionary`.
+ Questa richiesta API di
```
POST /
{
"a": "Number",
"b": "Number",
"op": "String"
}
```
diventa il metodo SDK di
```
(AWSTask *)rootPost:(SIMPLE_CALCInput *)body
```
+ La richiesta API di
```
GET /{a}/{b}/{op}
```
diventa il metodo SDK di
```
(AWSTask *)aBOpGet:(NSString *)a b:(NSString *)b op:(NSString *)op
```
La procedura seguente descrive come chiamare i metodi API nel codice di origine delle app Objective-C, ad esempio nell'ambito del delegato `viewDidLoad` in un file `ViewController.m`.
**Per chiamare l'API mediante l'SDK iOS generato da API Gateway**
1. Importa il file di intestazione della classe client dell'API per rendere tale classe chiamabile nell'app:
```
#import "SIMPLE_CALCSimpleCalc.h"
```
L'istruzione `#import` inoltre importa `SIMPLE_CALCInput.h` e `SIMPLE_CALCResult.h` per le due classi di modelli.
1. Crea un'istanza della classe client dell'API:
```
SIMPLE_CALCSimpleCalcClient *apiInstance = [SIMPLE_CALCSimpleCalcClient defaultClient];
```
Per utilizzare Amazon Cognito con l'API, impostare la proprietà `defaultServiceConfiguration` sull'oggetto `AWSServiceManager` predefinito, come mostrato di seguito, prima di chiamare il metodo `defaultClient` per creare l'oggetto client dell'API (mostrato nell'esempio precedente):
```
AWSCognitoCredentialsProvider *creds = [[AWSCognitoCredentialsProvider alloc] initWithRegionType:{{AWSRegionUSEast1}} identityPoolId:{{your_cognito_pool_id}}];
AWSServiceConfiguration *configuration = [[AWSServiceConfiguration alloc] initWithRegion:{{AWSRegionUSEast1}} credentialsProvider:creds];
AWSServiceManager.defaultServiceManager.defaultServiceConfiguration = configuration;
```
1. Chiama il metodo `GET /?a=1&b=2&op=+` per eseguire `1+2`:
```
[[apiInstance rootGet: @"+" a:@"1" b:@"2"] continueWithBlock:^id _Nullable(AWSTask * _Nonnull task) {
_textField1.text = [self handleApiResponse:task];
return nil;
}];
```
dove la funzione dell'helper `handleApiResponse:task` formatta il risultato come stringa da visualizzare in un campo di testo (`_textField1`).
```
- (NSString *)handleApiResponse:(AWSTask *)task {
if (task.error != nil) {
return [NSString stringWithFormat: @"Error: %@", task.error.description];
} else if (task.result != nil && [task.result isKindOfClass:[SIMPLE_CALCResult class]]) {
return [NSString stringWithFormat:@"%@ %@ %@ = %@\n",task.result.input.a, task.result.input.op, task.result.input.b, task.result.output.c];
}
return nil;
}
```
Il risultato visualizzato è `1 + 2 = 3`.
1. Chiama `POST /` con un payload per eseguire `1-2`:
```
SIMPLE_CALCInput *input = [[SIMPLE_CALCInput alloc] init];
input.a = [NSNumber numberWithInt:1];
input.b = [NSNumber numberWithInt:2];
input.op = @"-";
[[apiInstance rootPost:input] continueWithBlock:^id _Nullable(AWSTask * _Nonnull task) {
_textField2.text = [self handleApiResponse:task];
return nil;
}];
```
Il risultato visualizzato è `1 - 2 = -1`.
1. Chiama `GET /{a}/{b}/{op}` per eseguire `1/2`:
```
[[apiInstance aBOpGet:@"1" b:@"2" op:@"div"] continueWithBlock:^id _Nullable(AWSTask * _Nonnull task) {
_textField3.text = [self handleApiResponse:task];
return nil;
}];
```
Il risultato visualizzato è `1 div 2 = 0.5`. Nell'esempio, `div` viene usato al posto di `/` perché la [funzione Lambda semplice](simple-calc-nodejs-lambda-function.md) nel back-end non gestisce le variabili di percorso con codifica URL.
## Utilizzo di un SDK iOS (Swift) generato per chiamare l'API
Prima di iniziare la procedura seguente, devi completare le fasi descritte in [Genera SDKs per REST APIs in API Gateway](how-to-generate-sdk.md) per iOS in Swift e scaricare il file .zip dell'SDK generato.
**Topics**
+ [Installa SDK AWS mobile e SDK generato da API Gateway in un progetto Swift](#use-sdk-ios-swift-install-sdk)
+ [Chiamata ai metodi API mediante l'SDK iOS generato da API Gateway in un progetto Swift](#use-sdk-ios-swift-call-api)
### Installa SDK AWS mobile e SDK generato da API Gateway in un progetto Swift
La procedura seguente descrive come installare l'SDK.
**Per installare e utilizzare un SDK iOS generato da API Gateway in Swift**
1. Estrai il contenuto del file .zip generato da API Gateway scaricato precedentemente. Utilizzando l'[SimpleCalc API](simple-calc-lambda-api.md), potresti voler rinominare la cartella SDK decompressa con qualcosa del genere. **sdk\_swift\_simple\_calc** In questa cartella SDK sono presenti un file `README.md` e un file `Podfile`. Il file `README.md` contiene le istruzioni per installare e usare l'SDK. Questo tutorial fornisce i dettagli relativi alle istruzioni. L'installazione consente di importare i componenti Mobile [CocoaPods](https://cocoapods.org)SDK richiesti. AWS Devi aggiornare il file `Podfile` per importarli SDKs nel progetto Xcode della tua app Swift. La cartella SDK non archiviata contiene anche una cartella `generated-src` con il codice sorgente dell'SDK generato dell'API.
1. Avvia Xcode e crea un nuovo progetto Swift per iOS. Prendi nota della destinazione del progetto. Dovrai specificare questa impostazione nel `Podfile`.
1. Per importare i componenti AWS Mobile SDK richiesti nel progetto Xcode utilizzando CocoaPods, procedi come segue:
1. Se non è installato, installalo CocoaPods eseguendo il seguente comando in una finestra di terminale:
```
sudo gem install cocoapods
pod setup
```
1. Copia il file `Podfile` dalla cartella SDK estratta nella stessa directory in cui si trova il file di progetto Xcode. Sostituisci il blocco seguente:
```
target '{{}}' do
pod 'AWSAPIGateway', '~> 2.4.7'
end
```
con il nome di destinazione del progetto, come mostrato
```
target '{{app_swift_simple_calc}}' do
pod 'AWSAPIGateway', '~> 2.4.7'
end
```
Se il progetto Xcode già contiene un `Podfile` con la destinazione corretta, puoi semplicemente aggiungere la riga di codice seguente al loop `do ... end`:
```
pod 'AWSAPIGateway', '~> 2.4.7'
```
1. Apri una finestra del terminale ed esegui il comando seguente nella directory dell'app:
```
pod install
```
Questo installa il componente API Gateway e tutti i componenti AWS Mobile SDK dipendenti nel progetto dell'app.
1. Chiudi il progetto Xcode e apri il file `*.xcworkspace` per riavviare Xcode.
1. Aggiungi tutti i file di intestazione dell'SDK (`.h`) e i file del codice di origine Swift (`.swift`) dalla directory `generated-src` estratta nel progetto Xcode.
1. Per abilitare la chiamata alle librerie Objective-C di AWS Mobile SDK dal tuo progetto di codice Swift, imposta il percorso del `Bridging_Header.h` file nella proprietà **Objective-C Bridging Header** sotto **Swift** Compiler - Impostazione generale della configurazione del tuo progetto Xcode:
**Suggerimento**
È possibile digitare **bridging** nella casella di ricerca di Xcode per trovare la proprietà **Objective-C Bridging Header (Intestazione bridging Objective-C)**.
1. Prima di procedere, crea il progetto Xcode per verificare che sia configurato correttamente. Se il tuo Xcode utilizza una versione di Swift più recente di quella supportata per Mobile SDK, otterrai errori nel compilatore Swift. AWS In questo caso, impostare la proprietà **Use Legacy Swift Language Version (Usa versione linguaggio Swift legacy)** su **Yes (Sì)** in **Swift Compiler - Version (Compilatore Swift - Versione)**:
Per importare AWS Mobile SDK for iOS in Swift nel tuo progetto AWS scaricando esplicitamente Mobile SDK o [utilizzando](https://github.com/Carthage/Carthage#installing-carthage) Carthage, segui le istruzioni nel `README.md` file fornito con il pacchetto SDK. Assicurati di utilizzare solo una di queste opzioni per importare Mobile SDK. AWS
### Chiamata ai metodi API mediante l'SDK iOS generato da API Gateway in un progetto Swift
Quando avete generato l'SDK con il prefisso di `SIMPLE_CALC` for questa [SimpleCalc API](simple-calc-lambda-api.md) con due modelli per descrivere l'input (`Input`) e l'output (`Result`) delle richieste e delle risposte dell'API, nell'SDK, la classe client API risultante diventa `SIMPLE_CALCSimpleCalcClient` e le classi di dati corrispondenti sono `SIMPLE_CALCInput` e, rispettivamente. `SIMPLE_CALCResult` Le richieste e le risposte API sono mappate ai metodi SDK come segue:
+ La richiesta API di
```
GET /?a=...&b=...&op=...
```
diventa il metodo SDK di
```
public func rootGet(op: String?, a: String?, b: String?) -> AWSTask
```
La proprietà `AWSTask.result` è del tipo `SIMPLE_CALCResult`, se il modello `Result` è stato aggiunto alla risposta del metodo. In caso contrario, è del tipo `NSDictionary`.
+ Questa richiesta API di
```
POST /
{
"a": "Number",
"b": "Number",
"op": "String"
}
```
diventa il metodo SDK di
```
public func rootPost(body: SIMPLE_CALCInput) -> AWSTask
```
+ La richiesta API di
```
GET /{a}/{b}/{op}
```
diventa il metodo SDK di
```
public func aBOpGet(a: String, b: String, op: String) -> AWSTask
```
La procedura seguente descrive come chiamare i metodi API nel codice di origine delle app Swift, ad esempio nell'ambito del delegato `viewDidLoad()` in un file `ViewController.m`.
**Per chiamare l'API mediante l'SDK iOS generato da API Gateway**
1. Crea un'istanza della classe client dell'API:
```
let client = SIMPLE_CALCSimpleCalcClient.default()
```
Per utilizzare Amazon Cognito con l'API, imposta una configurazione di AWS servizio predefinita (mostrata di seguito) prima di ottenere il `default` metodo (mostrato in precedenza):
```
let credentialsProvider = AWSCognitoCredentialsProvider(regionType: {{AWSRegionType.USEast1}}, identityPoolId: "{{my_pool_id}}")
let configuration = AWSServiceConfiguration(region: {{AWSRegionType.USEast1}}, credentialsProvider: credentialsProvider)
AWSServiceManager.defaultServiceManager().defaultServiceConfiguration = configuration
```
1. Chiama il metodo `GET /?a=1&b=2&op=+` per eseguire `1+2`:
```
client.rootGet("+", a: "1", b:"2").continueWithBlock {(task: AWSTask) -> AnyObject? in
self.showResult(task)
return nil
}
```
dove la funzione dell'helper `self.showResult(task)` stampa il risultato o l'errore nella console, ad esempio:
```
func showResult(task: AWSTask) {
if let error = task.error {
print("Error: \(error)")
} else if let result = task.result {
if result is SIMPLE_CALCResult {
let res = result as! SIMPLE_CALCResult
print(String(format:"%@ %@ %@ = %@", res.input!.a!, res.input!.op!, res.input!.b!, res.output!.c!))
} else if result is NSDictionary {
let res = result as! NSDictionary
print("NSDictionary: \(res)")
}
}
}
```
In un'app di produzione puoi visualizzare il risultato o l'errore in un campo di testo. Il risultato visualizzato è `1 + 2 = 3`.
1. Chiama `POST /` con un payload per eseguire `1-2`:
```
let body = SIMPLE_CALCInput()
body.a=1
body.b=2
body.op="-"
client.rootPost(body).continueWithBlock {(task: AWSTask) -> AnyObject? in
self.showResult(task)
return nil
}
```
Il risultato visualizzato è `1 - 2 = -1`.
1. Chiama `GET /{a}/{b}/{op}` per eseguire `1/2`:
```
client.aBOpGet("1", b:"2", op:"div").continueWithBlock {(task: AWSTask) -> AnyObject? in
self.showResult(task)
return nil
}
```
Il risultato visualizzato è `1 div 2 = 0.5`. Nell'esempio, `div` viene usato al posto di `/` perché la [funzione Lambda semplice](simple-calc-nodejs-lambda-function.md) nel back-end non gestisce le variabili di percorso con codifica URL.