Share
UIKit è la struttura che ti troverai più spesso quando sviluppi applicazioni iOS. Definisce i componenti principali di un'applicazione iOS, da etichette e pulsanti a visualizzazioni di tabelle e controller di navigazione. In questo articolo, non solo inizieremo la nostra esplorazione del framework UIKit, esploreremo anche gli interni di un progetto iOS e gli elementi costitutivi di base delle applicazioni iOS.
Mentre il framework Foundation definisce classi, protocolli e funzioni per lo sviluppo sia di iOS che di OS X, il framework UIKit è esclusivamente orientato allo sviluppo di iOS. È l'equivalente del Kit di applicazione o AppKit framework per lo sviluppo di OS X..
Come Foundation, UIKit definisce classi, protocolli, funzioni, tipi di dati e costanti. Aggiunge inoltre funzionalità aggiuntive a varie classi Foundation, come ad esempio NSObject, NSString, e NSValue attraverso l'uso delle categorie Objective-C.
Le categorie Objective-C sono un modo conveniente per aggiungere metodi extra alle classi esistenti senza la necessità di sottoclassi. Leggi questo tutorial di Aaron Crabtree se vuoi saperne di più sulle categorie Objective-C.
Invece di esplorare le classi chiave di UIKit come abbiamo fatto per il framework Foundation, creeremo e viaggeremo attraverso un nuovo progetto iOS ed esploreremo le classi che incontriamo. Prendendo questo approccio, diventerà rapidamente chiaro in quale contesto viene utilizzata una classe e in che modo ciascuna classe si inserisce nello schema più ampio di un'applicazione iOS e quale ruolo gioca.
Avvia Xcode e crea un nuovo progetto selezionando Nuovo> Progetto ... dal File menu. Nella sezione iOS a sinistra, seleziona il Applicazione categoria. Dall'elenco dei modelli di progetto, scegliere il Applicazione vista singola modello.
Il modello di applicazione a vista singola contiene i componenti di base di un'applicazione iOS ed è quindi un buon punto di partenza per il nostro viaggio.
Assegna un nome al progetto UIKit e inserire il nome di un'organizzazione e l'identificativo della società. Immettere un prefisso di classe, come ho spiegato in precedenza in questa serie, e impostare dispositivi a i phone.
Dillo a Xcode dove vuoi salvare il nuovo progetto e assicurati di mettere il progetto sotto controllo di versione selezionando la casella di controllo Crea repository git sul mio Mac. Rivedi questo articolo per ulteriori informazioni sul controllo della versione e sui relativi vantaggi.
Abbiamo appreso un bel po 'di cose nuove dall'ultima volta che abbiamo creato un progetto iOS da zero quindi è una buona idea esplorare i vari file e cartelle del nostro nuovo progetto per vedere se suonano un campanello.
Nel Project Navigator, dovresti vedere tre cartelle alla radice del progetto;
Diamo un'occhiata al contenuto di ciascuna di queste cartelle.
Il Prodotti la cartella contiene attualmente due elementi. Il primo oggetto porta il nome del nostro progetto e ha un'estensione di .App. Il nome del secondo oggetto termina in test e ha un'estensione di .xctest. Non copro i test unitari di questa serie, quindi per il momento puoi ignorare il secondo elemento.
La cartella Prodotti contiene l'applicazione o le applicazioni create dal progetto dopo la compilazione del codice sorgente.
L'hai notato? UIKit.app è evidenziato in rosso? Ogni volta che Xcode non è in grado di individuare un file, evidenzia il file in rosso. Poiché il progetto non è ancora stato compilato, Xcode non ha ancora creato il prodotto.
Il Frameworks la cartella contiene i framework a cui è collegato il tuo progetto. Nel precedente articolo, il nostro progetto era solo collegato al framework della Fondazione. Questo progetto, tuttavia, si basa su un modello di applicazione iOS e pertanto è collegato a quattro framework, Foundation, UIKit, Core Graphics e XCTest.
Potresti ricordare il framework Core Graphics di prima in questa serie. Il framework contiene le interfacce per l'API di disegno 2D (Quartz). Il framework XCTest è correlato al test delle unità, che non tratterò in questa serie.
C'è un'altra posizione nel nostro progetto che specifica a quali strutture è collegato il progetto. Seleziona il tuo progetto nel Project Navigator, scegli l'unico oggetto nel obiettivi sezione a sinistra e apri il Costruisci fasi scheda in alto.
Aprendo il Collega binario con le librerie cassetto, ti viene presentata la stessa lista di framework che abbiamo visto nella cartella Frameworks. Collegare il nostro progetto a un altro framework di sistema iOS è facile come fare clic sul pulsante più in fondo all'elenco e selezionare un framework dall'elenco.
La maggior parte del tempo viene speso nella cartella del progetto, che attualmente contiene sei file e una cartella nominata File di supporto. Iniziamo dando un'occhiata al contenuto della cartella dei file di supporto.
Accentsconagua
principale funzione, che è dove inizia tutta la magia. Anche se non modificheremo main.m, è essenziale per la tua applicazione iOS.Ora che sappiamo quali sono i diversi file e cartelle nel nostro progetto, è tempo di esplorare i diversi componenti di un'applicazione iOS. Mentre proseguiamo il nostro viaggio, incontreremo diverse classi che appartengono a UIKit. Ogni classe che appartiene al framework UIKit inizia con il prefisso della classe UI. Ricorda che le classi Foundation sono precedute da NS.
Prima di iniziare ad esplorare il framework UIKit, voglio parlare del pattern Model-View-Controller (MVC). Il pattern MVC è uno dei pattern più diffusi nella programmazione orientata agli oggetti. Promuove la riusabilità del codice e ha stretti legami con il concetto di separazione di responsabilità o preoccupazioni. Uno degli obiettivi principali del pattern MVC è la separazione della logica di business di un'applicazione dal livello di presentazione.
Cocoa Touch abbraccia il pattern MVC ed è quindi importante capire cos'è e come funziona. In altre parole, comprendendo il pattern MVC, sarà molto più facile capire in che modo i diversi componenti di un'applicazione iOS lavorano insieme.
Nel modello MVC, un modello ha il controllo della logica aziendale di un'applicazione. Interagire con un database, ad esempio, è responsabilità del modello. La vista presenta i dati gestiti dal modello all'utente. La vista gestisce l'interfaccia utente e l'input dell'utente.
Il controller è la colla tra il modello e la vista. Mentre il modello e la vista non conoscono l'esistenza l'uno dell'altro, il controller conosce sia il modello che la vista.
Poiché il controller conosce sia il modello che la vista, è spesso la parte meno riusabile di un'applicazione. Meno un oggetto conosce il suo ambiente e gli oggetti con cui interagisce, maggiore è la sua riusabilità nei progetti futuri.
UIApplicationAnche se il UIApplication la classe è un componente chiave di ogni applicazione iOS, non interagirai molto spesso con essa e raramente, se non mai, sentirai il bisogno di sottoclasse UIApplication.
Quando viene avviata un'applicazione, viene creato un singleton di questa classe. Ti ricordi cos'è un oggetto singleton? Significa che solo una istanza di oggetto di UIApplication la classe viene creata durante la vita di un'applicazione.
Il UIApplication istanza è il punto di ingresso per l'interazione dell'utente e invia gli eventi agli oggetti target appropriati. Il significato esatto di ciò diventerà chiaro in pochi minuti quando daremo un'occhiata ai controller di visualizzazione.
Nella maggior parte delle applicazioni iOS, il UIApplication l'istanza ha un oggetto delegato ad esso associato. Ogni volta che crei un progetto iOS utilizzando uno dei modelli forniti, Xcode creerà per te una classe di delega dell'applicazione. Dai un'occhiata ai nomi dei file sorgente nella cartella del progetto in Project Navigator. I primi due file sono nominati TSPAppDelegate.
L'istanza di questa classe è il delegato di UIApplication singleton. Prima di dare un'occhiata più da vicino al TSPAppDelegate classe, abbiamo bisogno di capire qual è il modello delegato.
Ole Begemann ha scritto un eccellente articolo sulla sequenza di lancio di una tipica applicazione iOS. In questo articolo, parla dei vari componenti coinvolti e del loro ruolo durante la sequenza di avvio dell'applicazione. Consiglio vivamente di leggere questo articolo se si desidera ottenere una migliore comprensione del ruolo di UIApplication classe così come il misterioso principale() funzione in main.m.
Il pattern delegato viene ampiamente utilizzato in Cocoa e Cocoa Touch. Nel prossimo articolo di questa serie, in cui esploreremo i dettagli di una vista tabella, scopriremo che le visualizzazioni delle tabelle dipendono in gran parte dal modello delegato (e dall'origine dati).
Come il pattern MVC, la delega è comune nella programmazione orientata agli oggetti. Il modello delegato in Cocoa Touch, tuttavia, è leggermente diverso, perché utilizza un protocollo delegato per definire il comportamento dell'oggetto delegato.
Andiamo avanti e diamo un'occhiata alle visualizzazioni delle tabelle. Se hai trascorso un po 'di tempo con un iPhone o iPad, allora il UITableView la classe dovrebbe esserti familiare. Presenta un elenco ordinato di dati all'utente e fa questo lavoro molto bene.
In che modo una vista tabella sa cosa fare quando viene toccata una riga? Questo comportamento è incluso nel UITableView classe? Certamente no, perché questo comportamento varia da un'applicazione all'altra. Se dovessimo includere questo comportamento nel UITableView classe, non sarebbe molto riutilizzabile.
La vista del tavolo outsourcers questa responsabilità verso un oggetto delegato. Metti diversamente, delegati questo compito a un altro oggetto, a delegare oggetto. Prenditi un momento per esaminare il riferimento di classe del UITableView classe. Ha due proprietà denominate fonte di dati e delegare. Il delegare viene notificato dalla visualizzazione tabella ogni volta che un utente tocca una riga. È responsabilità dell'oggetto delegato rispondere al tocco dell'utente.
L'origine dati della vista tabella è simile in termini di comportamento. La differenza principale è che la vista tabella chiede l'oggetto origine dati per qualcosa, i dati che deve essere visualizzato.
Delegare e oggetti di origine dati, come ad esempio la vista tabella delegare e fonte di dati oggetti, sono quasi sempre classi personalizzate, classi che crei, perché la loro implementazione è specifica dell'applicazione.
Prima di dare un'occhiata al TSPAppDelegate classe, è importante capire che un oggetto delegato è conforme a un protocollo delegato. Nel precedente articolo, abbiamo già imparato a conoscere i protocolli in Objective-C e come definiscono il comportamento definendo un elenco di metodi che i suoi utenti adottano per implementare.
Ora che sappiamo cos'è la delega, è tempo di esplorare il TSPAppDelegate classe che Xcode ha creato per noi. All'avvio dell'applicazione, l'applicazione crea un'istanza di TSPAppDelegate classe. In genere, non è mai necessario creare un'istanza esplicita di un oggetto delegato dell'applicazione.
Apri il file di intestazione del file TSPAppDelegate classe (TSPAppDelegate.h) per esaminarne il contenuto. Se ignoriamo i commenti nella parte superiore, la prima riga importa i file di intestazione del framework UIKit in modo che possiamo lavorare con le sue classi e protocolli.
#importare
La prossima linea dovrebbe essere familiare. Questo è l'inizio dell'interfaccia del TSPAppDelegate classe come indicato dal @interfaccia direttiva. Specifica il nome della classe e la superclasse della classe, UIResponder.
Tra parentesi angolari sono i protocolli a cui la classe si conforma. Il TSPAppDelegate classe è conforme a un protocollo, il UIApplicationDelegate protocollo.
@interface TSPAppDelegate: UIResponder
La riga successiva è una dichiarazione di proprietà, che dovrebbe sembrare familiare. La proprietà, finestra, è un'istanza di UIWindow, che è una sottoclasse di UIView. Le parole tra parentesi, forte e nonatomic, sono attributi di proprietà facoltativi che specificano la semantica di archiviazione e il comportamento della proprietà. Puoi ignorarli per ora.
@property (strong, nonatomic) finestra UIWindow *;
La parte più interessante dell'interfaccia di TSPAppDelegate la classe è il UIApplicationDelegate protocollo. Dai un'occhiata al riferimento del UIApplicationDelegate protocollo per un elenco completo dei metodi definiti dal protocollo.
Il protocollo definisce dozzine di metodi e vi incoraggio ad esplorarne alcuni per avere un'idea delle capacità del protocollo. Il metodo che ci interessa di più a questo punto è applicazione: didFinishLaunchingWithOptions:.
Quando il UIApplication l'istanza ha finito di preparare la domanda di lancio, notificherà il delegato, il nostro TSPAppDelegate istanza, che l'applicazione finirà il lancio, ma che non ha ancora.
Perché notifica il delegato dell'applicazione di questo evento? Il UIApplication istanza notifica al proprio delegato l'evento in modo che abbia l'opportunità di prepararsi per l'avvio dell'applicazione. Dirigetevi verso il file di implementazione di TSPAppDelegate per vedere cosa intendo Il primo metodo nel file di implementazione è applicazione: didFinishLaunchingWithOptions: e dovrebbe più o meno apparire come quello incollato sotto.
- Applicazione (BOOL): l'applicazione (UIApplication *) ha fattoFinishLaunchingWithOptions: (NSDictionary *) launchOptions return YES;
Il applicazione: didFinishLaunchingWithOptions: metodo fornisce un riferimento al UIApplication istanza e un dizionario con opzioni, che non ci interessano a questo punto. L'implementazione del metodo è piuttosto semplice. Tutto ciò che fa è tornare SÌ dire al UIApplication istanza che l'applicazione è pronta per il lancio.
Il progetto Xcode contiene un altro file interessante, Main.storyboard. Lo storyboard definisce come sarà l'interfaccia utente della nostra applicazione. Per impostazione predefinita, lo storyboard è denominato Main.storyboard. Seleziona lo storyboard per aprirlo.
Lo storyboard contiene attualmente una vista nell'area di lavoro centrale. A destra del Project Navigator puoi vedere una lista di oggetti, che sono gli oggetti che vedi nella vista. Il primo oggetto è nominato Visualizza scena controller, che contiene un elemento figlio etichettato Visualizza controller.
Il Visualizza controller l'oggetto ha anche un numero di oggetti figlio, ma ce n'è uno che ci interessa di più, l'oggetto chiamato vista. Ricorda la nostra discussione sul pattern MVC. Qui puoi vedere lo schema MVC in azione. Al momento il modello è mancante, ma abbiamo una visione, il vista oggetto e un controller, il Visualizza controller oggetto.
Quando viene avviata la nostra applicazione, lo storyboard viene utilizzato per creare l'interfaccia utente dell'applicazione. Il controller della vista viene automaticamente istanziato, così come la vista del controller della vista. Il vista l'oggetto nello storyboard è gestito dal controller della vista.
Apetta un minuto. Dove posso trovare la classe del controller di visualizzazione nello storyboard? Come posso cambiare il suo comportamento per creare un'applicazione unica? Seleziona il Visualizza controller oggetto a sinistra nello storyboard e apri il Identity Inspector sulla destra.
Il Identity Inspector ti dice tutto ciò che devi sapere. In alto, nella sezione Classe personalizzata, puoi vedere il nome della classe del controller della vista, TSPViewController. Hai notato che i due file di cui non abbiamo ancora parlato hanno lo stesso nome? Esploreremo questi file in pochi istanti.
Il controller di visualizzazione è istanziato per noi, perché è il controller di visualizzazione iniziale dello storyboard. Questo è indicato nello storyboard dalla freccia che punta allo storyboard.
UIViewControllerSe apri TSPViewController.h, noterai che il TSPViewController la classe è una sottoclasse di UIViewController. Piace TSPAppDelegate, il UIViewController la classe è una sottoclasse di UIResponder. Visualizza i controller, o sottoclassi di essi, rientrano nel controllore categoria del modello MVC. Come suggerisce il nome, controllano una vista, un'istanza del UIView classe, che cade nel vista categoria del modello MVC.
Un controller di visualizzazione gestisce una vista e le visualizzazioni secondarie della vista come vedremo in seguito. Per fare ciò, il controller della vista deve conoscere la vista. In altre parole, deve avere un riferimento alla vista.
Il controller della vista nello storyboard ha un riferimento alla vista. È possibile verificare ciò selezionando il controller di visualizzazione nello storyboard e aprendo il Connections Inspector sulla destra.
Nel Connections Inspector, dovresti vedere una sezione chiamata Punti vendita. Il termine outlet è una parola di fantasia per una proprietà, che puoi impostare nello storyboard. Passa con il mouse sopra la presa denominata vista e osserva come viene evidenziata la vista nell'area di lavoro. Questa è la connessione tra il controller della vista e la vista.
UIViewAnche se la tua applicazione può avere solo un'istanza di UIWindow, può avere molte viste. Il UIView la classe è un componente importante del framework UIKit, perché molte classi ne ereditano, direttamente o indirettamente.
Rivisitare Main.storyboard selezionandolo e dai un'occhiata al Libreria di oggetti in fondo al Ispettore.
Sfoglia la libreria degli oggetti e trascina a etichetta e a pulsante alla vista nell'area di lavoro. Non importa dove li posizioni nella vista finché si trovano nella vista del controller della vista.
Avrai notato che due nuovi oggetti sono stati aggiunti al Oggetti sezione a sinistra. Sia l'etichetta (UILabel) e il pulsante (UIButton) ereditato da UIView. Hai notato che il Etichetta e Pulsante gli oggetti sono leggermente rientrati rispetto al vista oggetto? Questo indica che il Etichetta e Pulsante gli oggetti sono sottoview di vista oggetto. Una vista può avere una o più sottoview che gestisce.
Come ho detto prima, il UIView la classe è un componente importante di UIKit. Una vista gestisce un'area rettangolare o una cornice sullo schermo. Gestisce i contenuti dell'area, le sottoview e qualsiasi interazione con i contenuti della vista. Il UIView la classe è una sottoclasse di UIResponder. Imparerai molto di più sulle viste nel corso di questa serie.
Diamo un'occhiata a un esempio per illustrare la relazione tra lo storyboard, la vista che contiene e il controller di visualizzazione. Queste tre componenti sono importanti e voglio essere sicuro di capire come funzionano insieme.
Pochi minuti fa, hai aggiunto un'etichetta e un pulsante alla vista del controller della vista. Come fa il controller di visualizzazione a sapere di questi oggetti? Al momento, non appaiono nel Connections Inspector, ma possiamo cambiarlo dicendo al controller della vista su di loro.
Aprire il file di intestazione del controller della vista (TPSViewController.h) e aggiungere una proprietà per l'etichetta e per il pulsante.
@property IBOutlet UILabel * myLabel; @property IBOutlet UIButton * myButton;
Aggiungendo il IBOutlet parola chiave alla dichiarazione di proprietà, le proprietà appariranno in Connections Inspection nello storyboard e questo è ciò che vogliamo.
Tornate allo storyboard, selezionate il Visualizza controller oggetto nel Visualizza scena controller, e apri il Connections Inspector sulla destra. Le nuove proprietà sono ora elencate nell'elenco di Punti vendita. Tuttavia, il controller della vista non ha ancora creato il connessione tra le nuove proprietà e gli oggetti nello storyboard.
Questo è facile da rimediare. Trascina dal cerchio vuoto a sinistra di myLabel uscita all'etichetta nell'area di lavoro. Ciò creerà quella connessione importantissima in modo che il controller della vista sia a conoscenza dell'etichetta. Fai lo stesso per il pulsante.
Anche se possiamo modificare il testo dell'etichetta nello storyboard, facciamolo nel controller della vista per illustrare che il controller della vista ha accesso all'etichetta e al pulsante nello storyboard.
Aprire il file di implementazione del controller di visualizzazione (TPSViewController.m) e cerca il viewDidLoad metodo. Modifica il viewDidLoad metodo per riflettere l'implementazione di seguito. I commenti sono stati omessi per chiarezza.
- (void) viewDidLoad [super viewDidLoad]; [self.myLabel setText: @ "Questa è un'istanza di UILabel."];
Possiamo inviare messaggi alla proprietà dell'etichetta chiedendo al controller di visualizzazione, se stesso, per il suo myLabel proprietà. Inviando il myLabel proprietà un messaggio di setText: e passando una stringa letterale, aggiorniamo il testo dell'etichetta.
Nota che setText: è un accessorio o setter. Anche se è possibile usare la notazione a punti di Objective-C (vedi sotto), ho usato la sintassi più tradizionale in quanto mostra meglio ciò che sta realmente accadendo.
self.myLabel.text = @ "Questa è un'istanza di UILabel";
Esegui la tua applicazione in iOS Simulator facendo clic su Correre pulsante in alto a sinistra e si noti che il testo dell'etichetta viene effettivamente aggiornato.
Abbiamo esplorato molte nuove cose in questo articolo. Voglio concludere questa puntata parlando di azioni. Proprio come gli outlets, le azioni non sono altro che metodi che puoi vedere nello storyboard.
Vediamo come funziona. Aprire il file di intestazione del controller della vista (TPSViewController.h) e aggiungere la seguente dichiarazione del metodo da qualche parte nel blocco di interfaccia del controller della vista.
- (IBAction) ChangeColor: (id) del mittente;
Non essere confuso dal IBAction parola chiave. IBAction è identico a vuoto, il che significa che il metodo non restituisce alcun valore. Se osserviamo più da vicino la dichiarazione del metodo, possiamo vedere che richiede un argomento di tipo id, un riferimento a un oggetto Objective-C.
Come suggerisce il nome dell'argomento, l'argomento del metodo o dell'azione è l'oggetto che ha inviato il messaggio al controller della vista. Spiegherò questo in modo più dettagliato in un po '.
Rivisitare lo storyboard, selezionare il Visualizza controller oggetto nel Visualizza scena controller, e apri il Connections Inspector. Una nuova sezione è apparsa nel Connections Inspector di nome Azioni ricevute e l'azione che abbiamo appena aggiunto è elencata in questa sezione.
Trascina dal cerchio vuoto a sinistra dell'azione al pulsante nell'area di lavoro. Dovrebbe apparire una piccola finestra con un elenco di opzioni. L'elenco contiene tutti gli eventi possibili a cui il pulsante può rispondere. Quello che ci interessa è Ritocca Dentro. Questo evento viene attivato quando un utente tocca il pulsante e alza il dito mentre è ancora all'interno del pulsante.
Crea ed esegui nuovamente la tua applicazione e tocca il pulsante. Anche l'applicazione si è bloccata per te? Come è successo? Quando hai premuto il pulsante, ha inviato un messaggio di cambia colore: al controller della vista. Anche se il controller della vista dichiara a cambia colore: metodo, non implementa ancora questo metodo.
Ogni volta che un messaggio viene inviato a un oggetto che non implementa un metodo corrispondente, viene sollevata un'eccezione e l'applicazione si arresta in modo anomalo se l'eccezione non viene rilevata. È possibile verificare ciò eseguendo l'applicazione ancora una volta, toccando il pulsante e ispezionando l'output nella finestra della console.
Per ovviare a questo, dobbiamo implementare il cambia colore: metodo. Aprire il file di implementazione del controller di visualizzazione (TPSViewController.m) e aggiungere la seguente implementazione del metodo da qualche parte nel blocco di implementazione.
- (IBAction) changeColor: (id) sender NSLog (@ "Sender Class>% @", [classe mittente]); NSLog (@ "Sender Superclass>% @", [superclasse mittente]); int r = arc4random ()% 255; int g = arc4random ()% 255; int b = arc4random ()% 255; UIColor * color = [UIColor colorWithRed: (r / 255.0) green: (g / 255.0) blue: (b / 255.0) alpha: 1.0]; [self.view setBackgroundColor: color];
L'implementazione del cambia colore: il metodo è identico a quello che abbiamo usato in precedenza in questa serie. Tuttavia, ho aggiunto due extra NSLog chiama alla sua implementazione per mostrarti che il mittente del messaggio è effettivamente il pulsante che abbiamo aggiunto allo storyboard.
Il metodo stesso è piuttosto semplice. Generiamo tre numeri interi casuali tra 0 e 255, passare questi valori a colorWithRed: verde: blu: alpha: per generare un colore casuale e aggiornare il colore di sfondo della vista del controller della vista con il colore generato casualmente.
Nota che self.view fa riferimento alla vista che il controller della vista gestisce e che abbiamo visto in precedenza nello storyboard.
Crea ed esegui la tua applicazione ancora una volta, tocca il pulsante e non dimenticare di controllare l'output nella finestra della console Xcode. Noterai che il mittente è un'istanza di UIButton e la sua superclasse è UIControl.
In questo articolo abbiamo esplorato alcune classi del framework UIKit e abbiamo esaminato attentamente i vari componenti di un'applicazione iOS. Esploreremo e lavoreremo con il framework UIKit in modo più dettagliato nel resto di questa serie.
Se non comprendi pienamente i vari concetti e modelli, allora sono certo che lo farai mentre la serie progredisce. Non esitate a lasciare un commento se avete domande su questo articolo.
