Contenuto

• Devo conoscere Swift?
• Imposta l'IDE Xcode di Apple
• Per iniziare: crea un nuovo progetto Xcode
• Team di sviluppo richiesto?
• Comprensione dell'IDE Xcode di Apple
• AppleDelegate: esame del file sorgente Swift
• 1. Creare un punto di ingresso
• 2. Definisci il tuo delegato di app
• 3. Definire una proprietà della finestra
• 4. Implementazioni Stub assortite
• Test del progetto: esecuzione del simulatore iOS
• Creazione di un'interfaccia utente con Interface Builder
• Accesso alla Libreria oggetti di iOS
• Personalizzazione degli oggetti con Impostazioni attributi
• Anteprima della tua interfaccia utente
• Connessione dell'interfaccia utente al codice sorgente
• Creazione di un metodo di azione
• 1. Indicare che questo metodo è un'azione
• 2. Dichiarare il metodo
• 3. Definire alcuni parametri
• Controlla la connessione
• Creazione di una finestra di avviso
• 1. Dichiarare una costante
• 2. Imposta il contenuto di
• 3. Imposta lo stile
• 4. Aggiungi un'azione
• 5. Visualizza l'avviso
• Test dell'app iOS completata
• Avvolgendo

Android potrebbe essere uno dei sistemi operativi più popolari al mondo, ma è tutt'altro che l'unico sistema operativo mobile!

Se desideri che la tua applicazione mobile raggiunga il pubblico più vasto possibile, dovrai scegliere come target più piattaforme. Mentre tu poteva optare per uno strumento di sviluppo multipiattaforma come Flutter, è inoltre possibile creare più codebase, che consente di offrire un'esperienza utente progettata e personalizzata per ciascuna piattaforma mobile.

Forse vuoi rilasciare la tua ultima app mobile su Android e iOS, forse stai pensando di saltare la nave ad Apple, o forse sei solo curioso di vedere come lo sviluppo per iOS è paragonabile allo sviluppo per Android. Qualunque sia la tua motivazione, in questo articolo ti mostrerò come iniziare a sviluppare per iOS, creando una semplice app per iPad e iPhone.

Lungo la strada, ti fornirò un'introduzione ai concetti chiave del linguaggio di programmazione Swift di Apple, ti guiderò attraverso le principali aree dell'ambiente di sviluppo integrato Xcode e ti mostrerò come testare i tuoi progetti nel simulatore iOS - nel caso in cui tu non mi sono ancora impegnato ad acquistare un iPad o iPhone!

Ecco cosa devi sapere per iniziare a sviluppare per iOS.

Devo conoscere Swift?

Quando inizi a sviluppare per iOS, in genere puoi scegliere tra due linguaggi di programmazione: Objective-C o Swift. Lanciato nel 2014, Swift è il linguaggio più moderno, inoltre Apple sembra spingere Swift su Objective-C per lo sviluppo di iOS, quindi userò Swift in questo tutorial.

Se sei un esperto Swift esperto, allora avrai un vantaggio. Tuttavia, anche se non l'hai mai fatto visto una sola riga di Swift prima, sarai ancora in grado di seguire, e alla fine di questo articolo avrai creato un'applicazione iOS funzionante, scritta interamente in Swift.

Mentre costruiamo la nostra app iOS, spiegherò i concetti chiave di questo linguaggio di programmazione, così avrai una panoramica di base di Swift e capirai Esattamente cosa succede in ogni riga di codice, anche se sei completamente nuovo su Swift.

Sfortunatamente, non avrai imparato un linguaggio di programmazione completamente nuovo quando raggiungerai la fine di questa pagina, ma se decidi di proseguire lo sviluppo di iOS, ti consiglio di dare un'occhiata all'app Swift Playgrounds. Questa applicazione contiene esercizi Learn to Code, presentati come puzzle interattivi che ti aiuteranno a familiarizzare con gli elementi essenziali di Swift di cui avrai bisogno, al fine di continuare a esplorare lo sviluppo di iOS.

Imposta l'IDE Xcode di Apple

Per sviluppare per iPhone e iPad, avrai bisogno di un Mac con macOS 10.11.5 o versioni successive. Se non sei sicuro di quale versione di macOS stai attualmente eseguendo, allora:

• Seleziona il logo "Apple" nella barra dei menu del tuo Mac.
• Seleziona "Informazioni su questo Mac".
• Assicurarsi che la scheda "Panoramica" sia selezionata; la tua versione di macOS dovrebbe apparire in questa finestra.

Avrai anche bisogno di Xcode, che è l'ambiente di sviluppo integrato (IDE) di Apple. Xcode ha tutti gli strumenti e le funzionalità necessarie per progettare, sviluppare e eseguire il debug di applicazioni per macOS, watchOS, tvOS - e iOS.

Per scaricare l'ultima versione di Xcode:

• Avvia l'App Store sul tuo Mac.
• Nel campo "Cerca", inserisci "Xcode".
• Quando viene visualizzata l'applicazione Xcode, selezionare "Ottieni" seguito da "Installa app".
• Quando richiesto, inserisci l'ID Apple e la password. Se non disponi di un ID Apple, puoi crearne uno gratuitamente. Xcode verrà ora scaricato nella cartella "Applicazioni" del tuo Mac.
• Al termine del download di Xcode, avviarlo. Leggi i termini e le condizioni e, se sei felice di procedere, fai clic su "Accetto".
• Se Xcode richiede di scaricare del software aggiuntivo, seguire le istruzioni visualizzate per scaricare questi componenti mancanti.

Per iniziare: crea un nuovo progetto Xcode

Simile ad Android Studio, Xcode viene fornito con una serie di modelli per le categorie comuni di applicazioni iOS, come la navigazione basata su schede e giochi. Questi modelli includono codice e file boilerplate che possono aiutarti a far ripartire i tuoi progetti iOS. In questo articolo, utilizzeremo uno di questi modelli già pronti.

Per creare un nuovo progetto Xcode:

• Avvia l'IDE Xcode, se non l'hai già fatto.
• Dopo alcuni istanti, apparirà la schermata “Benvenuti in Xcode”; seleziona "Crea un nuovo progetto Xcode". Se la schermata di benvenuto non viene visualizzata, seleziona "File> Nuovo> Progetto" dalla barra dei menu di Xcode.
• Nella finestra "Scegli un modello per il tuo nuovo progetto", assicurati che la scheda "iOS" sia selezionata.
• Seleziona il modello "App vista singola", quindi fai clic su "Avanti".
• In "Nome prodotto", inserisci "HelloWorld". Xcode lo utilizzerà per nominare il tuo progetto e la tua applicazione.
• Se lo si desidera, immettere un "Nome organizzazione" facoltativo.
• Inserisci il tuo "Identificatore dell'organizzazione". Se non disponi di un identificatore, puoi utilizzare "com.example". Nota che "Identificatore del pacchetto" viene generato automaticamente in base al nome del prodotto e all'identificatore dell'organizzazione, quindi non devi preoccuparti di questo.
• Apri il menu a discesa "Lingue" e seleziona "Swift".
• Trova la casella di controllo "Usa dati principali" e assicurati che lo sia non selezionato.
• Seleziona la casella di controllo "Includi test unitari".
• Trova la casella di controllo "Includi test dell'interfaccia utente" e assicurati che lo sia non selezionato.
• Fai clic su "Avanti".
• Nella finestra di dialogo successiva, selezionare la posizione in cui si desidera salvare il progetto, quindi fare clic su "Crea".

Xcode ora caricherà il progetto nella sua finestra dell'area di lavoro.

Team di sviluppo richiesto?

A questo punto, Xcode potrebbe visualizzare il seguente errore "La firma per HelloWorld richiede un team di sviluppo".

Prima di poter eseguire il progetto su un dispositivo iOS fisico, devi impostare un team valido e firmare la tua applicazione. Poiché stiamo solo sperimentando iOS, non è necessario completare il processo di firma ora, ma è necessario firmare l'applicazione prima che possa essere eseguita su un dispositivo fisico o accedere a determinati servizi, come Game Center o In-App acquisti.

Comprensione dell'IDE Xcode di Apple

L'area di lavoro di Xcode è dove scriverai tutto il codice sorgente della tua app, progetterai e costruirai la tua interfaccia utente (UI) e creerai tutti i file e le risorse aggiuntivi che alla fine si uniranno per formare la tua applicazione iOS completa.

Xcode è ricco di funzionalità, ma come nuovo arrivato nello sviluppo di iOS, ci sono alcune aree che devi conoscere:

• (1) Area di navigazione. Questa area fornisce un accesso rapido e semplice a tutti i diversi file e risorse che compongono il tuo progetto. Puoi esaminare il contenuto di un file selezionandolo nell'area di navigazione. Si noti che è necessario solo selezionare il file in questione; facendo doppio clic su un file verrà avviato in una nuova finestra esterna.
• (2) Area dell'editor. A seconda del file selezionato nell'area di navigazione, Xcode visualizzerà diverse interfacce nell'area dell'editor. Più comunemente, utilizzerai l'area Editor per scrivere il codice sorgente della tua applicazione e costruirne l'interfaccia utente.
• Area di utilità. Questa area è divisa in due sezioni. La parte superiore dell'area Utilità (3) visualizza il riquadro Impostazioni, in cui puoi visualizzare le informazioni sull'elemento che hai selezionato nell'area Navigazione o Editor e modificarne gli attributi. La parte inferiore dell'area Utilità (4) visualizza il riquadro Libreria, che consente di accedere ad alcuni elementi dell'interfaccia utente già pronti, frammenti di codice e altre risorse.

AppleDelegate: esame del file sorgente Swift

Il modello di app a visualizzazione singola include tutto il codice Swift e le risorse necessarie per creare un'applicazione iOS semplice ma funzionante.

Puoi vedere tutti questi file e risorse generati automaticamente nell'area di navigazione (verso il lato sinistro dell'area di lavoro Xcode).

Se l'area di navigazione non è visibile, è possibile convincerla a nascondersi selezionando "Visualizza> Navigatori> Mostra navigatore di progetto" dalla barra dei menu Xcode.

Il modello dell'applicazione Visualizzazione semplice genera automaticamente diversi file, ma iniziamo esaminando "AppleDelegate.swift". Seleziona questo file nell'area di navigazione e l'area dell'editor dovrebbe aggiornarsi per visualizzare il contenuto del file.

import UIKit @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate {var window: UIWindow? // In Swift, dichiari un metodo usando la parola chiave "func" // func application (_ application: UIApplication, didFinishLaunchingWithOptions launchOptions:?) -> Bool {return true} // Definisci un parametro "application" con il tipo "UIApplication "// func applicationWillResignActive (_ application: UIApplication) {} func applicationDidEnterBackground (_ application: UIApplication) {} func applicationWillEnterForeground (_ application: UIApplication) {} func applicationDidBecomeActive (_ application: UIApplication) {} func applicationWillTerminate: ) {}}

Diamo un'occhiata più da vicino a ciò che sta accadendo in questo file:

1. Creare un punto di ingresso

L'attributo @UIApplicationMain crea un punto di ingresso nell'app e un ciclo di esecuzione, che è un ciclo di elaborazione degli eventi che consente di pianificare il lavoro e coordinare gli eventi di input all'interno dell'applicazione.

@UIApplicationMain

2. Definisci il tuo delegato di app

Il file AppDelegate.swift definisce una classe AppleDelegate, che crea la finestra in cui viene disegnato il contenuto dell'app e fornisce un posto per rispondere alle transizioni di stato, ad esempio ogni volta che l'app passa allo sfondo o viene portata in primo piano.

class AppDelegate: UIResponder, UIApplicationDelegate {

Nel codice sopra, stiamo anche adottando il protocollo UIApplicationDelegate, che definisce diversi metodi che puoi utilizzare per configurare l'app e gestire vari eventi a livello di app.

3. Definire una proprietà della finestra

La classe AppDelegate contiene una proprietà "window", che memorizza un riferimento alla finestra dell'applicazione. Questa proprietà rappresenta la radice della gerarchia di visualizzazione della tua app ed è dove verranno disegnati tutti i contenuti della tua app.

var var: UIWindow?

4. Implementazioni Stub assortite

La classe AppDelegate contiene anche implementazioni di stub per diversi metodi delegati, come:

func applicationDidEnterBackground (_ application: UIApplication) {

Questi metodi consentono all'oggetto app di comunicare con il delegato dell'app. Ogni volta che l'applicazione cambia stato, l'oggetto dell'app chiamerà il metodo delegato corrispondente, ad esempio quando l'app passa in background chiamerà il metodo applicationDidEnterBackground sopra.

Ognuno di questi metodi delegati ha un comportamento predefinito, ma è possibile definire comportamenti personalizzati aggiungendo il proprio codice. Ad esempio, in genere si espande sull'implementazione dello stub applicationDidEnterBackground aggiungendo codice per rilasciare eventuali risorse condivise. Il metodo applicationDidEnterBackground è anche il punto in cui è necessario archiviare informazioni sullo stato sufficienti per ripristinare l'applicazione allo stato corrente, nel caso in cui l'app venga chiusa mentre è in background.

Oltre a applicationDidEnterBackground, AppleDelegate.swift contiene i seguenti metodi:

• didFinishLaunchingWithOptions. Informa il delegato che il processo di avvio è quasi completo e l'applicazione è quasi pronta per essere eseguita. Dovresti utilizzare questo metodo per completare l'inizializzazione della tua app e apportare eventuali modifiche finali, prima che l'interfaccia utente della tua applicazione venga presentata all'utente.
• applicationWillResignActive. Indica al delegato che l'applicazione sta per passare da uno stato attivo a uno inattivo. Questo metodo può essere attivato da un'interruzione temporanea, ad esempio una chiamata in arrivo, o quando l'applicazione inizia a passare a uno stato in background. Quando l'app è inattiva, dovrebbe eseguire un lavoro minimo, quindi è necessario utilizzare applicationWillResignActive per mettere in pausa le attività in corso e disabilitare eventuali timer. Dovresti anche cogliere l'occasione per salvare tutti i dati non salvati, quindi non andranno persi se l'utente sceglie di chiudere l'applicazione mentre è in background.
• applicationWillEnterForeground. In iOS 4.0 e versioni successive, questo metodo viene chiamato come parte della transizione della tua app dallo sfondo a uno stato attivo e in primo piano. È necessario utilizzare questo metodo per annullare le modifiche apportate quando l'applicazione è entrata in background.
• applicationDidBecomeActive. Questo indica al delegato che la tua app è passata da uno stato inattivo a uno attivo. In genere, ciò si verifica quando l'utente o il sistema avvia l'applicazione, ma può anche verificarsi se l'utente sceglie di ignorare un'interruzione che sposta l'app in uno stato temporaneo inattivo, come una chiamata in arrivo o un SMS. È necessario utilizzare il metodo applicationDidBecomeActive per riavviare qualsiasi attività sospesa mentre l'applicazione era inattiva.
• applicationWillTerminate. Questo metodo informa il delegato che l'applicazione sta per terminare. Utilizzare questo metodo per eseguire tutte le operazioni di pulizia necessarie, ad esempio il salvataggio dei dati utente o la liberazione di risorse condivise. Basta essere consapevoli del fatto che questo metodo ha circa cinque secondi per eseguire le sue attività e tornare, e se supera questo limite di tempo, il sistema può decidere di terminare completamente il processo.

Test del progetto: esecuzione del simulatore iOS

Da quando abbiamo utilizzato il modello di app a visualizzazione singola, il nostro progetto contiene già abbastanza codice per l'esecuzione su iOS.

Puoi mettere alla prova il tuo progetto iOS, usando il simulatore iOS che è preconfezionato con Xcode. Simile all'emulatore di Android Studio, iOS Simulator ti consente di testare l'aspetto e il funzionamento della tua app su una vasta gamma di dispositivi, inclusi dispositivi con dimensioni e risoluzioni dello schermo diverse.

Eseguiamo il nostro progetto nel simulatore iOS:

• Seleziona "Imposta lo schema attivo" (dove si trova il cursore nella seguente schermata).

• Scegli il dispositivo che desideri emulare, ad esempio "iPhone 8", "iPad Air 2" o "iPhone X". Il simulatore emula iPhone 8 Plus per impostazione predefinita.
• Nella parte superiore sinistra della barra degli strumenti Xcode, selezionare il pulsante "Esegui" (in cui il cursore è posizionato nella schermata seguente).

• Se è la prima volta che collaudi un'app per iOS, Xcode ti chiederà se vuoi abilitare la modalità sviluppatore. La modalità sviluppatore consente a Xcode di accedere ad alcune funzionalità di debug senza richiedere la tua password ogni volta, quindi a meno che tu non abbia un motivo specifico per non farlo, in genere vorrai abilitare la modalità sviluppatore.

Una volta che Xcode ha finito di costruire il tuo progetto, iOS Simulator si avvia e inizia a caricare la tua app. Simile all'emulatore Android, a volte può essere un processo lento, quindi potresti aver bisogno di pazientare (magari usalo come un'opportunità per prenderti un caffè!)

Una volta caricata la tua applicazione, ti troverai di fronte a una semplice schermata bianca. Il modello di app a visualizzazione singola potrebbe essere un'applicazione iOS funzionante, ma non è esattamente una eccitante applicazione, quindi aggiungiamo alcuni elementi dell'interfaccia utente.

Creazione di un'interfaccia utente con Interface Builder

Interface Builder di Xcode ti offre un modo visivo per progettare e costruire l'interfaccia utente della tua applicazione, in modo simile a come funziona l'editor di layout in Android Studio.

Se dai un'occhiata all'area di navigazione, vedrai che il modello di app a visualizzazione singola ha già generato un file "Main.storyboard", che è un storyboard file. Uno Storyboard è una rappresentazione visiva dell'interfaccia utente della tua app, che puoi modificare in Interface Builder.

Per dare un'occhiata allo Storyboard della nostra app, seleziona il file Main.storyboard nell'area di navigazione. Interface Builder dovrebbe aprirsi automaticamente e visualizzare l'interfaccia utente della tua app, che al momento è composta da un'unica schermata.

Questa schermata contiene un'unica vista, con una freccia che punta verso il lato sinistro dello schermo. Questa freccia rappresenta il punto di ingresso dello Storyboard, che è la prima schermata che l'utente vede quando avvia l'app.

Accesso alla Libreria oggetti di iOS

Il modo più semplice per creare la tua interfaccia utente è utilizzare gli elementi di Xcode Biblioteca d'oggetti. Questa libreria contiene oggetti con una presenza sullo schermo visibile, ad esempio Viste immagine, Barre e interruttori di navigazione e oggetti che definiscono il comportamento ma non hanno una presenza visibile, come i riconoscimenti dei gesti e le viste contenitore.

Creeremo un pulsante che, quando toccato, visualizza un avviso. Cominciamo prendendo un pulsante dalla Libreria oggetti e aggiungendolo alla nostra app:

• Verso la parte in basso a destra dell'area di lavoro Xcode, selezionare il pulsante "Mostra libreria oggetti". In alternativa, puoi selezionare "Visualizza> Utilità> Mostra libreria oggetti" dal menu di Xcode.

• La Libreria oggetti dovrebbe ora visualizzare un elenco di tutti i diversi elementi che è possibile aggiungere all'interfaccia utente. Scorri questo elenco per vedere quali opzioni sono disponibili.
• Vogliamo aggiungere un pulsante, quindi digita "pulsante" nel campo di testo "Filtro", quindi seleziona il pulsante quando appare nell'elenco.
• Trascina l'oggetto pulsante sulla tela. Mentre trascini, apparirà una serie di guide orizzontali e verticali che ti aiuteranno a posizionare il pulsante. Quando sei soddisfatto del posizionamento, rilascia il mouse per aggiungere il pulsante all'interfaccia utente.

Personalizzazione degli oggetti con Impostazioni attributi

Successivamente, dobbiamo aggiungere del testo al pulsante. Puoi personalizzare gli oggetti utilizzando la finestra di ispezione degli attributi di Xcode:

• Seleziona "Visualizza> Utilità> Mostra ispettore attributi" dalla barra degli strumenti Xcode; Inspector Attributi ora dovrebbe apparire verso il lato destro dell'area di lavoro Xcode.

• Nella tua tela, seleziona l'oggetto pulsante.
• Nella finestra di ispezione degli attributi, trova la sezione "Titolo" e sostituisci il testo predefinito "Pulsante" con un testo tutto tuo.
  Premi il tasto "Invio" sulla tastiera e Interface Builder aggiornerà il pulsante per includere il tuo nuovo testo.

A questo punto, potresti voler sperimentare alcuni degli altri attributi del pulsante, ad esempio potresti cambiare il colore di sfondo del pulsante o il carattere utilizzato per il suo testo.

Anteprima della tua interfaccia utente

Sebbene sia possibile testare le applicazioni eseguendole sul simulatore iOS, questo non è sempre il modo più semplice per monitorare il modo in cui l'applicazione si sta formando.

Quando crei la tua interfaccia utente, puoi risparmiare un po 'di tempo visualizzando in anteprima le modifiche nella finestra "Anteprima" di Xcode, che è un editor secondario che viene visualizzato come parte del normale spazio di lavoro Xcode.

• Seleziona "Visualizza> Modifica> Mostra Assistente Editor" dalla barra dei menu di Xcode.
• Nella barra dei menu dell'Editor Assistant, seleziona "Automatico".

• Seleziona "Anteprima> Main.storyboard (Anteprima)". Assistant Editor ora visualizzerà un'anteprima dell'interfaccia utente della tua app accanto alla normale area Editor.
• Per visualizzare l'anteprima dell'interfaccia utente della tua app in diversi orientamenti, scorri fino alla fine della finestra Anteprima e seleziona il pulsante "Ruota".

Connessione dell'interfaccia utente al codice sorgente

Nello sviluppo di iOS, il codice dell'app e la tua interfaccia utente sono separati, al punto in cui abbiamo creato un'interfaccia utente di base senza dover scrivere una singola riga di codice. Tuttavia, c'è un aspetto negativo nel mantenere separati il ​​codice e l'interfaccia utente: è necessario stabilire esplicitamente una relazione tra il codice sorgente e l'interfaccia utente, approfondendo le classi UIViewController e ViewController del progetto.

UIViewController è un componente fondamentale delle applicazioni iOS, che è responsabile del mantenimento di elementi dell'interfaccia utente come pulsanti, cursori e campi di testo. Per impostazione predefinita, UIViewController ha una vista vuota, quindi è necessario creare una classe personalizzata che estende UIViewController, noto come View Controller.

Se apri il file "ViewController.swift" del tuo progetto, vedrai che il modello di app a visualizzazione singola ha già generato un controller di visualizzazione per noi:

class ViewController: UIViewController {

Attualmente, questa classe ViewController eredita semplicemente tutto il comportamento definito da UIViewController, ma è possibile estendere e personalizzare questo comportamento predefinito sovrascrivendo i metodi definiti da UIViewController.Ad esempio, attualmente il file ViewController.swift sovrascrive il metodo viewDidLoad (), ma in realtà non fare qualsiasi cosa tranne chiamare la versione di UIViewController di questo metodo:

override func viewDidLoad () {super.viewDidLoad () // Esegui qualsiasi configurazione aggiuntiva dopo aver caricato la vista //}

Sebbene esuli dallo scopo di questa esercitazione, puoi personalizzare la risposta di View Controller a questo evento aggiungendo il tuo codice al metodo viewDidLoad (), ad esempio è qui che in genere esegui qualsiasi configurazione aggiuntiva richiesta dalla tua app.

Dietro le quinte, il modello dell'app Single View ha creato automaticamente una connessione tra la classe ViewController.swift e Main.storyboard. In fase di esecuzione, lo Storyboard creerà un'istanza di ViewController e i contenuti dello Storyboard verranno visualizzati sullo schermo.

Questo ci dà un vantaggio, ma dobbiamo ancora collegare i singoli elementi all'interno del nostro Storyboard, al nostro file ViewController.swift, in modo che il codice sorgente possa comunicare con questi singoli elementi.

Il nostro compito è creare una connessione tra il nostro pulsante e la sezione appropriata del nostro codice sorgente, in modo che la nostra applicazione visualizzi un avviso ogni volta che l'utente tocca il pulsante.

Creazione di un metodo di azione

Toccando un pulsante è un evento, quindi dobbiamo crearne uno metodo di azione, che è una sezione di codice che definisce come l'applicazione deve rispondere a un determinato evento.

Per creare un metodo di azione:

• Nell'area di navigazione, assicurarsi che il file Main.storyboard sia selezionato.
• Apri Xcode Assistant Assistant, selezionando "Visualizza> Editor Assistant> Mostra Assistant Editor".
• Nella barra di selezione dell'editor, fai clic su "Automatico", quindi seleziona "Automatico> ViewController.swift".
• A questo punto, sia il file ViewController.swift che lo Storyboard dovrebbero essere visibili sullo schermo. Nel file ViewController.swift, trova la seguente riga e aggiungi alcune righe di spazio vuoto sotto di esso:

class ViewController: UIViewController {

• Nello Storyboard, seleziona l'elemento dell'interfaccia utente del pulsante in modo che sia evidenziato in blu.
• Tieni premuto il tasto Ctrl e trascina il pulsante nello spazio vuoto appena creato nel file ViewController.swift. Dovrebbe apparire una linea blu, che indica dove verrà creato il metodo di azione.

• Quando sei soddisfatto della posizione del metodo, rilascia il pulsante e dovrebbe apparire un popup.
• Nel popup, apri il menu a discesa "Connessione" e seleziona "Azione".
• Successivamente, apri il menu a discesa "Evento" e seleziona "Ritocco interno", che è un evento che verrà attivato ogni volta che l'utente solleva il dito all'interno del pulsante.
• Dai a questa azione il nome "alertController".
• Fai clic su "Connetti".

Xcode ora creerà il seguente metodo "alertController":

@IBAction func alertController (_ mittente: qualsiasi) {}

Analizziamo esattamente cosa sta succedendo qui:

1. Indicare che questo metodo è un'azione

L'attributo "IBAction" espone questo metodo a Interface Builder come azione, che consente di connettere questo metodo agli oggetti dell'interfaccia utente:

@IBAction

2. Dichiarare il metodo

In Swift, dichiariamo un metodo usando la parola chiave "func", seguita dal nome del metodo:

func alertControlle ()

3. Definire alcuni parametri

Successivamente, definiamo alcuni parametri opzionali all'interno di una serie di parentesi, che il nostro metodo utilizzerà quindi come input.

Ogni set di parametri dovrebbe avere un nome e un tipo, separati da due punti (:).

func alertController (_ mittente: qualsiasi) {

Qui, il metodo accetta un parametro "mittente", che si riferisce all'oggetto responsabile dell'innesco dell'azione, ovvero il nostro pulsante. Stiamo anche affermando che questo parametro può essere di tipo "Qualsiasi".

Ora, ogni volta che l'utente tocca il pulsante, la nostra app invocherà il metodo alertController (metodo _ mittente :).

Controlla la connessione

Dopo aver creato il nostro metodo "alertController", possiamo verificare che sia correttamente collegato al pulsante:

• Nell'area di navigazione, selezionare il file "Main.storyboard".
• Nella barra dei menu di Xcode, seleziona "Visualizza> Utilità> Mostra ispettore connessioni". L'ispettore connessioni ora dovrebbe aprirsi lungo il lato destro dell'area di lavoro Xcode.
• Nell'area Editor, seleziona il tuo pulsante.

L'ispettore Connections dovrebbe ora visualizzare alcune informazioni su questo pulsante, inclusa una sezione "Eventi inviati", che contiene un elenco di eventi disponibili e il metodo corrispondente che verrà chiamato ogni volta che si verifica ogni evento.

Possiamo vedere che l'evento "Ritocca dentro" è collegato al nostro metodo "alertController", quindi sappiamo che ogni volta che l'utente interagisce con questo pulsante verrà chiamato il metodo "alertController".

Tuttavia, c'è un problema: in realtà non abbiamo definito cosa dovrebbe accadere quando viene chiamato il metodo "alertController"!

Creazione di una finestra di avviso

In iOS, puoi creare un avviso usando UIAlertController, che è approssimativamente equivalente a AlertDialog di Android.

Apri il tuo file ViewController.swift e aggiungi quanto segue:

class ViewController: UIViewController {@IBAction func showAlert (_ mittente: qualsiasi) {let alertController = UIAlertController (titolo: "Title",: "Hello, world!", favoriteStyle: .alert) alertController.addAction (UIAlertAction (title: "Annulla ", style: .default)) self.present (alertController, animato: true, completamento: zero)}

Diamo un'occhiata più da vicino a cosa sta succedendo qui:

1. Dichiarare una costante

In Swift, dichiari le costanti con la parola chiave "let", quindi iniziamo dichiarando una costante chiamata alertController:

lasciate alertController

2. Imposta il contenuto di

Ora possiamo definire il titolo dell'avviso e:

let alertController = UIAlertController (title: "Title",: "Hello, world!")

3. Imposta lo stile

Poiché si tratta di un avviso, sto utilizzando lo stile "Avviso":

let alertController = UIAlertController (title: "Title",: "Hello, world!", favoriteStyle: .alert)

4. Aggiungi un'azione

Successivamente, stiamo aggiungendo un pulsante di azione, utilizzando il metodo addAction ():

alertController.addAction (UIAlertAction (titolo: "Annulla", stile: .default))

5. Visualizza l'avviso

Dopo aver configurato il nostro oggetto UIAlertController, siamo pronti a mostrarlo all'utente. Nel frammento seguente, chiediamo a ViewController di presentare all'oggetto alertController un'animazione:

self.present (alertController, animato: true, completamento: zero)}

Test dell'app iOS completata

Ora è il momento di mettere alla prova il nostro progetto:

• Seleziona il pulsante "Esegui" nella barra degli strumenti di Xcode.
• Una volta che l'applicazione viene visualizzata nel simulatore iOS, fai un clic sul pulsante: l'avviso ora dovrebbe apparire sullo schermo!

Avvolgendo

In questo tutorial, abbiamo avuto alcune esperienze pratiche con lo sviluppo per iOS. Abbiamo creato una semplice applicazione, composta da un pulsante e un avviso, mentre ci familiarizziamo con l'IDE Xcode e il linguaggio di programmazione Swift.

Hai piani per iniziare a sviluppare app per iPhone e iPad? O preferisci strumenti di sviluppo multipiattaforma come Flutter? Fateci sapere nei commenti qui sotto!