Quickstarters
Come creare un backend per WatchOS?

40min
Introduzione
In questo tutorial, scoprirai come costruire un backend per watchOS app utilizzando Back4App. 
Che tu stia creando un estensione WatchKit per la tua app iPhone o progettando un'esperienza Apple Watch, Back4App semplifica il tuo lavoro fornendo strumenti essenziali. 
Integrerai funzionalità come un database sicuro, Funzioni Cloud Code, query in tempo reale (Live Queries) e autenticazione degli utenti, il tutto senza gestire i tuoi server.
Vedrai anche come la rapida routine di avvio di Back4App e l'ambiente facile da usare ti permettano di concentrarti sulla funzionalità delle tue app watchOS, piuttosto che sulla configurazione dei server. 
Durante il percorso, imparerai a gestire compiti come pianificare lavori, impostare webhook e configurare notifiche push. 
Alla fine, avrai una solida base per estendere le tue app per watch o applicazioni iOS per esigenze a livello di produzione, il tutto mentre fornisci una sincronizzazione dei dati senza soluzione di continuità (su una connessione internet) tra l'app WatchKit e il tuo backend.
Prerequisiti
Un account Back4App e un nuovo progetto Back4App
 Iniziare con Back4app.
Se non hai un account, puoi crearne uno gratuitamente. Segui la guida sopra per preparare il tuo progetto.
Un ambiente di sviluppo watchOS/Xcode
 Dovresti avere Xcode installato con il watchOS SDK. Puoi eseguire e costruire la tua estensione WatchKit su un vero Apple Watch o su un simulatore.
Parse Swift SDK
Usa Swift Package Manager per installare e configurare l'SDK per le tue app watchOS o app iOS combinate.
Familiarità con Swift, Xcode e l'ecosistema di sviluppo di Apple
 Documentazione per sviluppatori Apple.
Se sei nuovo sulle piattaforme Apple, trascorri del tempo esplorando la documentazione di watchOS e iOS prima di iniziare.
Assicurati di soddisfare questi requisiti prima di iniziare. Avere il tuo progetto Back4App configurato e il tuo ambiente watchOS locale pronto ti aiuterà a seguire senza intoppi.
Passo 1 – Creare un nuovo progetto su Back4App e connettersi
Perché hai bisogno di un progetto Back4App
Un nuovo progetto Back4App è essenziale per memorizzare tutti i dati e eseguire il codice cloud per le tue app watchOS. Questo serve come base del tuo backend.
Crea il tuo progetto
Accedi a Back4App.
Clicca “Nuova App” nella dashboard.
Dai un nome alla tua app (ad esempio, “WatchOS-Backend-Tutorial”).
﻿
Installa Parse Swift SDK
Aggiungi la dipendenza Parse Swift nel tuo Package.swift o utilizzando File → Swift Packages → Aggiungi Dipendenza Pacchetto in Xcode. Fornisci l'URL:
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
Inizializza Parse nel tuo codice watchOS o condiviso
Nel codice di avvio della tua app WatchKit o in un file condiviso accessibile sia dalla tua watchOS che dalla tua iPhone app, inizializza Parse:
Swift
@main
struct MyWatchApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APP_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
@main
struct MyWatchApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APP_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
A questo punto, la tua watchOS app può comunicare con il backend di Back4App. Che si tratti di un Apple Watch app indipendente o di un WatchKit extension abbinata a un iPhone app, tutti i dati del backend fluiscono attraverso il Parse Swift SDK.
Passo 2 – Configurazione del Database
1. Creazione di un Modello di Dati
Back4App utilizza la funzionalità schema-on-write di Parse Server. Puoi definire tabelle (classi) nella sezione Back4App Database o lasciare che vengano create automaticamente quando gli oggetti vengono salvati per la prima volta. Ad esempio, se le tue watch apps tracciano i dati sulla salute, potresti avere una classe “HealthMetrics” con campi come heartRate, steps o workoutType.
2. Creare un Modello di Dati utilizzando l'Agente AI
L' Agente AI di Back4App ti consente di descrivere il tuo schema in linguaggio semplice:
Apri l' Agente AI nel tuo dashboard dell'app.
Fornisci dettagli come “Per favore, imposta una classe Watch Metrics con i campi: dailySteps (Numero), heartRate (Numero).”
L'AI creerà automaticamente lo schema per te.
﻿
3. Leggere e Scrivere Dati utilizzando l'SDK
Di seguito è riportato un esempio di salvataggio e interrogazione dei dati da un'app watchOS. Supponiamo di avere una HealthMetrics struct:
Swift
import ParseSwift

struct HealthMetrics: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var dailySteps: Int?
    var heartRate: Int?
}

// Saving data
func saveMetrics(steps: Int, heart: Int) async {
    var metrics = HealthMetrics()
    metrics.dailySteps = steps
    metrics.heartRate = heart

    do {
        let saved = try await metrics.save()
        print("Saved metrics: \(saved)")
    } catch {
        print("Error saving: \(error)")
    }
}

// Querying data
func fetchLatestMetrics() async {
    let query = HealthMetrics.query()
    do {
        let results = try await query.find()
        print("Fetched: \(results.count) items")
    } catch {
        print("Error fetching: \(error)")
    }
}
import ParseSwift

struct HealthMetrics: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var dailySteps: Int?
    var heartRate: Int?
}

// Saving data
func saveMetrics(steps: Int, heart: Int) async {
    var metrics = HealthMetrics()
    metrics.dailySteps = steps
    metrics.heartRate = heart

    do {
        let saved = try await metrics.save()
        print("Saved metrics: \(saved)")
    } catch {
        print("Error saving: \(error)")
    }
}

// Querying data
func fetchLatestMetrics() async {
    let query = HealthMetrics.query()
    do {
        let results = try await query.find()
        print("Fetched: \(results.count) items")
    } catch {
        print("Error fetching: \(error)")
    }
}
﻿
4. Lettura e Scrittura dei Dati utilizzando REST API
Se necessario, le tue watchOS o app iOS possono anche inviare richieste REST:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dailySteps": 8000, "heartRate": 75}' \
  https://parseapi.back4app.com/classes/HealthMetrics
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dailySteps": 8000, "heartRate": 75}' \
  https://parseapi.back4app.com/classes/HealthMetrics
﻿
5. Lettura e Scrittura dei Dati utilizzando GraphQL
Back4App fornisce anche un endpoint GraphQL. Ad esempio:
GraphQL
mutation {
  createHealthMetrics(input: {
    fields: {
      dailySteps: 7500
      heartRate: 70
    }
  }) {
    healthMetrics {
      objectId
      dailySteps
      heartRate
    }
  }
}
mutation {
  createHealthMetrics(input: {
    fields: {
      dailySteps: 7500
      heartRate: 70
    }
  }) {
    healthMetrics {
      objectId
      dailySteps
      heartRate
    }
  }
}
﻿
6. Lavorare con le Query Live (opzionale)
Se hai bisogno di aggiornamenti dei dati in tempo reale sul tuo Apple Watch, abilita le Query Live:
Attiva Live Queries nelle Impostazioni del Server in Back4App.
Configura l'URL della Query Live nel tuo codice watchOS:
Swift
ParseLiveQuery.configure(url: URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!)
ParseLiveQuery.configure(url: URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!)
﻿
Poi iscriviti ai cambiamenti:
Swift
func subscribeMetricsUpdates() async throws {
    let subscription = HealthMetrics.query().subscribe()
    for try await event in subscription {
        switch event {
        case .created(let newData):
            print("New data: \(newData)")
        case .updated(let updatedData):
            print("Updated: \(updatedData)")
        default:
            break
        }
    }
}
func subscribeMetricsUpdates() async throws {
    let subscription = HealthMetrics.query().subscribe()
    for try await event in subscription {
        switch event {
        case .created(let newData):
            print("New data: \(newData)")
        case .updated(let updatedData):
            print("Updated: \(updatedData)")
        default:
            break
        }
    }
}
﻿
Passo 3 – Applicare la Sicurezza con ACL e CLP
1. Breve Panoramica
Back4App consente liste di controllo degli accessi (ACL) e permessi a livello di classe (CLP) per proteggere il tuo database. Ad esempio, potresti limitare alcune metriche all'utente che le ha generate o consentire l'accesso in lettura solo agli account autenticati.
2. Configurazione passo dopo passo
Permessi a livello di classe
Vai a Database → Classe → Sicurezza per definire i valori predefiniti (ad es., solo lettura per tutti, scrittura per i proprietari).
ACL nel codice
Puoi aggiungere ACL a ciascun oggetto nel tuo WatchKit o codice condiviso. Ad esempio:
Swift
if let user = User.current {
    var acl = ParseACL()
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)

    var metrics = HealthMetrics()
    metrics.ACL = acl
}
if let user = User.current {
    var acl = ParseACL()
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)

    var metrics = HealthMetrics()
    metrics.ACL = acl
}
﻿
Questo assicura che solo l'utente connesso possa visualizzare o modificare gli oggetti HealthMetrics che crea.
Passo 4 – Scrivere funzioni di Cloud Code
1. Perché Cloud Code
Cloud Code ti aiuta a eseguire operazioni complesse o riservate lato server, come la validazione dei dati, le chiamate API esterne o il logging. Questa configurazione è utile per ridurre il carico di lavoro sui dispositivi watchOS e preservare la durata della batteria sull' Apple Watch.
2. Funzione di esempio
Nel tuo main.js:
JS
Parse.Cloud.define('processMetrics', async (request) => {
  const { dailySteps, heartRate } = request.params;
  if (!dailySteps || !heartRate) {
    throw 'Missing parameters.';
  }
  // Example: Simple calculation
  return dailySteps * heartRate;
});
Parse.Cloud.define('processMetrics', async (request) => {
  const { dailySteps, heartRate } = request.params;
  if (!dailySteps || !heartRate) {
    throw 'Missing parameters.';
  }
  // Example: Simple calculation
  return dailySteps * heartRate;
});
﻿
3. Distribuzione
Usa il Back4App CLI per distribuire:
Bash
b4a deploy
b4a deploy
﻿
4. Installazione dei moduli NPM
Se hai bisogno di librerie esterne nel tuo Cloud Code:
Aggiungi dipendenze in package.json (all'interno della tua cartella Cloud Code).
Usa require('your-lib') in main.js.
Passo 5 – Configurazione dell'autenticazione
1. Abilitare l'autenticazione degli utenti
Per impostazione predefinita, la classe Utente è pronta in Back4App. Assicurati che “Abilita autorizzazioni a livello di classe” sia impostato correttamente per gli oggetti utente.
2. Esempi di codice
In Parse Swift, puoi registrare un utente dal tuo codice watchOS:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpNewUser(name: String, pass: String, mail: String) async {
    var newUser = User()
    newUser.username = name
    newUser.password = pass
    newUser.email = mail

    do {
        let signedUp = try await newUser.signUp()
        print("Sign Up successful: \(signedUp)")
    } catch {
        print("Error signing up: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpNewUser(name: String, pass: String, mail: String) async {
    var newUser = User()
    newUser.username = name
    newUser.password = pass
    newUser.email = mail

    do {
        let signedUp = try await newUser.signUp()
        print("Sign Up successful: \(signedUp)")
    } catch {
        print("Error signing up: \(error)")
    }
}
﻿
3. Accesso sociale
Se prevedi di integrare l'accesso tramite Apple, Google o Facebook nella tua app watchOS o iPhone, puoi farlo con le relative funzionalità di accesso sociale di Parse Swift. Vedi Documentazione di Back4App per dettagli.
Passo 6 – Gestione dello storage dei file
1. Configurazione dello storage dei file
Se le tue app watch devono caricare immagini, log o piccoli file di dati, puoi fare affidamento su ParseFile:
Swift
func uploadFile(data: Data, fileName: String) async {
    let file = ParseFile(name: fileName, data: data)
    do {
        let savedFile = try await file.save()
        print("Uploaded file: \(savedFile.url ?? "")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
func uploadFile(data: Data, fileName: String) async {
    let file = ParseFile(name: fileName, data: data)
    do {
        let savedFile = try await file.save()
        print("Uploaded file: \(savedFile.url ?? "")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
﻿
2. Esempio
Potresti memorizzare immagini di allenamenti o istantanee dei progressi quotidiani:
Swift
let snapshotData = // ...some image data from watch screenshot
Task {
    await uploadFile(data: snapshotData, fileName: "workout.jpg")
}
let snapshotData = // ...some image data from watch screenshot
Task {
    await uploadFile(data: snapshotData, fileName: "workout.jpg")
}
﻿
3. Considerazioni sulla Sicurezza
Controlla le ACL dei tuoi file. Per impostazione predefinita, gli URL dei file sono accessibili se qualcuno ottiene il link diretto. Puoi proteggere o controllare l'accesso ai file tramite la configurazione dei file del tuo server parse.
Passo 7 – Verifica Email e Ripristino Password
1. Panoramica
Gli utenti di Apple Watch potrebbero non gestire sempre i login direttamente sull'orologio, ma abilitare la verifica email aiuta a mantenere i loro dati sicuri.
2. Configurazione del Dashboard di Back4App
Vai a Impostazioni App → Email.
Attiva Verifica Email.
Personalizza i modelli secondo necessità.
3. Codice/Implementazione
Per il ripristino della password:
Swift
do {
    try await User.requestPasswordReset(email: "[email protected]")
} catch {
    print("Error requesting password reset: \(error)")
}
do {
    try await User.requestPasswordReset(email: "example@domain.com")
} catch {
    print("Error requesting password reset: \(error)")
}
﻿
Swift
do {
    try await User.requestPasswordReset(email: "[email protected]")
} catch {
    print("Error requesting password reset: \(error)")
}
do {
    try await User.requestPasswordReset(email: "example@domain.com")
} catch {
    print("Error requesting password reset: \(error)")
}
﻿
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
1. Cosa Fanno i Cloud Jobs
I Cloud Jobs ti permettono di automatizzare compiti in background come la rotazione dei dati obsoleti o la generazione di report di utilizzo per le tue analisi watchOS.
2. Esempio
In main.js:
JS
Parse.Cloud.job('cleanUpMetrics', async (request) => {
  const query = new Parse.Query('HealthMetrics');
  // For example, remove records older than 7 days
  const now = new Date();
  const cutoff = new Date(now - 7 * 24 * 60 * 60 * 1000);
  query.lessThan('createdAt', cutoff);

  const oldMetrics = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldMetrics, { useMasterKey: true });
  return `Deleted ${oldMetrics.length} old records.`;
});
Parse.Cloud.job('cleanUpMetrics', async (request) => {
  const query = new Parse.Query('HealthMetrics');
  // For example, remove records older than 7 days
  const now = new Date();
  const cutoff = new Date(now - 7 * 24 * 60 * 60 * 1000);
  query.lessThan('createdAt', cutoff);

  const oldMetrics = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldMetrics, { useMasterKey: true });
  return `Deleted ${oldMetrics.length} old records.`;
});
﻿
Distribuisci il tuo codice.
Vai a Impostazioni App → Impostazioni Server → Compiti in Background e pianificalo quotidianamente.
Pianificazione di un Cloud Job
﻿
Passo 9 – Integrazione dei Webhook
1. Definizione
I webhook notificano i servizi esterni quando si verificano determinati eventi nella tua app. Ad esempio, potresti voler inviare un ping a un canale Slack ogni volta che viene registrato un nuovo metrica.
2. Configurazione
Nel dashboard di Back4App, vai a Altro → Webhook.
Aggiungi un webhook con un endpoint (come un URL Slack).
Scegli l'evento (ad es., “Nuovo record in HealthMetrics”).
Aggiunta di un Webhook
﻿
3. Esempio
Ogni volta che un utente aggiunge una nuova voce di dailySteps, il tuo canale Slack viene notificato. Puoi anche definire logiche più complesse nel Cloud Code per inviare payload personalizzati ai tuoi servizi esterni.
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
1. Dove Trovarlo
Il Pannello di Amministrazione è accessibile tramite la tua console Back4App sotto Altro → App di Amministrazione.
Abilitalo e crea un utente amministratore per la gestione dei dati basata sul web se hai bisogno di un'interfaccia semplice per i soggetti non tecnici.
Abilita l'App di Amministrazione
﻿
2. Caratteristiche
Visualizza e modifica i dati
Gestisci i log e i Cloud Jobs
Monitora le analisi o invia notifiche push
Questo è un modo semplice per collaborare sui dati senza bisogno di accesso diretto al database o al codice.
Conclusione
In questa guida, hai imparato come costruire un backend per watchOS utilizzando le potenti funzionalità di Back4App. Hai impostato uno schema di database sicuro, scritto Cloud Code, gestito query in tempo reale e implementato l'autenticazione degli utenti. Ora la tua app WatchKit può memorizzare e sincronizzare i dati con il minimo sforzo.
Prossimi Passi
Affina le tue app per smartwatch integrando funzioni cloud avanzate per notifiche personalizzate o trasformazioni dei dati.
Esplora ulteriori funzionalità delle applicazioni iOS, come la sincronizzazione in background e le strategie di caching per il tuo Apple Watch. 
Leggi la documentazione ufficiale di Back4App per ulteriori informazioni su sicurezza avanzata, analisi e prestazioni.
Ottimizza per l'App Store per distribuire la tua estensione watchOS o app per smartwatch autonoma.
Espandendo il tuo backend, puoi offrire robuste app per watchOS che funzionano senza problemi anche con una connessione internet limitata. Continua a costruire e goditi la potenza di Back4App per le tue esperienze su Apple Watch!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per jQuery?
AVANTI IL PROSSIMO
Come costruire un backend per tvOS?