Quickstarters
Come costruire un backend per tvOS?

42min
Introduzione
In questo tutorial, imparerai come costruire un backend per tvOS app utilizzando Back4App. 
Tratteremo l'integrazione delle funzionalità essenziali di Back4App—come la gestione del database, le Funzioni Cloud Code, le API REST e GraphQL, l'autenticazione degli utenti e le query in tempo reale (Live Queries)—per creare un backend sicuro e scalabile che comunica senza problemi con la tua Apple TV app costruita con il Parse Swift SDK.
Vedrai come l'ambiente semplificato di Back4App e la rapida configurazione riducono drasticamente il tempo rispetto alla configurazione manuale di server e database. 
Durante il percorso, acquisirai esperienza pratica con funzionalità chiave, inclusi avanzati strumenti di sicurezza, pianificazione di lavori cloud e integrazioni webhook.
Alla fine di questo tutorial, sarai pronto a migliorare questa struttura fondamentale in un'app tvOS pronta per la produzione o a includere facilmente logica personalizzata e API di terze parti. Questa guida aiuterà anche a mantenere un alta qualità dell'esperienza utente su Apple TV, sfruttando il tuo progetto Xcode e le tue conoscenze esistenti di sviluppo iOS.
Prerequisiti
Per completare questo tutorial, avrai bisogno di:
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.
Xcode (ultima versione stabile) installato
Costruirai la tua app tvOS con Swift o SwiftUI. Assicurati di avere l'ultima versione di Xcode dall'App Store di Mac.
Parse Swift SDK
Configura il Parse Swift SDK per connettere la tua app tvOS.
Familiarità con Swift e concetti di base dello sviluppo iOS/tvOS
Se sei nuovo su Apple TV, rivedi la documentazione Apple tvOS o un tutorial per principianti prima.
Assicurati di avere tutti questi prerequisiti in atto prima di iniziare. Avere il tuo progetto Back4App pronto e un progetto Xcode tvOS configurato ti aiuterà a seguire più facilmente.
Passo 1 – Creare un Nuovo Progetto su Back4App e Connettersi
Crea un Nuovo Progetto
Il primo passo per costruire il tuo backend dell'app tvOS su Back4App è creare un nuovo progetto. Se non lo hai già fatto, segui questi passaggi:
Accedi al tuo account Back4App.
Clicca sul pulsante “Nuova App” nel tuo dashboard di Back4App.
Dai un nome alla tua app (ad esempio, “tvOS-Backend-Tutorial”).
﻿
Una volta creato, vedrai il progetto elencato nel tuo dashboard di Back4App. Questo nuovo progetto Back4App è il nucleo di tutte le configurazioni backend trattate in questo tutorial.
Collegare il Parse Swift SDK
Back4App sfrutta Parse per gestire l'archiviazione dei dati, l'autenticazione degli utenti, le funzionalità in tempo reale e altro ancora. Per connettere la tua tvOS app a Back4App, installa e configura il Parse Swift SDK nel tuo Xcode project.
Recupera le tue chiavi Parse:
Nel tuo dashboard di Back4App, vai su “Impostazioni App” o “Sicurezza e Chiavi” per trovare il tuo Application ID e Client Key. Vedrai anche il Parse Server URL—comunemente https://parseapi.back4app.com.
﻿
Installa il Parse Swift SDK nel tuo progetto tvOS:
Swift Package Manager (Consigliato)
In Xcode, seleziona File → Aggiungi Pacchetti.
Inserisci l'URL GitHub di Parse Swift: https://github.com/netreconlab/Parse-Swift.git
Scegli la versione appropriata o il ramo principale.
CocoaPods
Se preferisci CocoaPods, aggiungi quanto segue al tuo Podfile:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Esegui quindi pod install.
Inizializza Parse nel tuo AppDelegate o @main struct:
Swift
import ParseSwift
import SwiftUI

@main
struct MyTVOSApp: 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()
        }
    }
}
import ParseSwift
import SwiftUI

@main
struct MyTVOSApp: 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()
        }
    }
}
﻿
Questo assicura che la tua tvOS app sia costruita per comunicare con il backend di Back4App, permettendoti di memorizzare dati, eseguire query, autenticare utenti e altro.
Passo 2 – Configurazione del Database
Creazione di un Modello di Dati
Con la tua app tvOS ora collegata a Back4App, puoi creare e gestire dati. In Parse Swift, definisci ParseObject structs:
Swift
struct GameScore: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom fields
    var score: Int?
    var playerName: String?
}
struct GameScore: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom fields
    var score: Int?
    var playerName: String?
}
﻿
Puoi anche definire manualmente le classi nel tuo dashboard di Back4App:
Vai a “Database” nella console di Back4App.
Crea una nuova classe (ad esempio, “GameScore”).
Aggiungi colonne rilevanti (punteggio, nomeGiocatore, ecc.).
Crea Nuova Classe
﻿
Creazione di un Modello Dati Utilizzando l'Agente AI
L'Agente AI di Back4App può progettare automaticamente il tuo schema:
Apri l'Agente AI nel tuo Dashboard di Back4App.
Descrivi il tuo modello (ad esempio, “Crea una classe ToDo con un campo titolo e isCompleted”).
Applica e lascia che l'Agente AI generi lo schema.
﻿
Lettura e Scrittura di Dati Utilizzando SDK
Swift
func saveScore() async {
    var gameScore = GameScore()
    gameScore.score = 1337
    gameScore.playerName = "tvOS Fan"
    do {
        try await gameScore.save()
        print("Score saved successfully.")
    } catch {
        print("Error saving score: \\(error)")
    }
}

func fetchScores() async {
    let query = GameScore.query()
    do {
        let results = try await query.find()
        print("Fetched scores: \\(results)")
    } catch {
        print("Error fetching scores: \\(error)")
    }
}
func saveScore() async {
    var gameScore = GameScore()
    gameScore.score = 1337
    gameScore.playerName = "tvOS Fan"
    do {
        try await gameScore.save()
        print("Score saved successfully.")
    } catch {
        print("Error saving score: \\(error)")
    }
}

func fetchScores() async {
    let query = GameScore.query()
    do {
        let results = try await query.find()
        print("Fetched scores: \\(results)")
    } catch {
        print("Error fetching scores: \\(error)")
    }
}
﻿
Lettura e Scrittura dei Dati Utilizzando REST API
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 '{"score": 9000, "playerName": "AppleFan"}' \
  https://parseapi.back4app.com/classes/GameScore
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 '{"score": 9000, "playerName": "AppleFan"}' \
  https://parseapi.back4app.com/classes/GameScore
﻿
Lettura e Scrittura dei Dati Utilizzando GraphQL API
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 420
      playerName: "Swiftie"
    }
  }) {
    gameScore {
      objectId
      score
      playerName
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 420
      playerName: "Swiftie"
    }
  }) {
    gameScore {
      objectId
      score
      playerName
    }
  }
}
﻿
Lavorare con le Query Live (opzionale)
Le Query Live possono alimentare aggiornamenti in tempo reale nella tua Apple TV interfaccia—particolarmente utili per app multi-giocatore o di leaderboard.
Abilita le Query Live nelle Impostazioni del Server della tua app su Back4App.
Inizializza una sottoscrizione:
Swift
let subscription = GameScore.query("score" > 1000).subscribeCallback { event in
    switch event {
    case .created(let score):
        print("New high score created: \\(score)")
    case .updated(let score):
        print("High score updated: \\(score)")
    case .deleted(let score):
        print("High score removed: \\(score)")
    default:
        break
    }
}
let subscription = GameScore.query("score" > 1000).subscribeCallback { event in
    switch event {
    case .created(let score):
        print("New high score created: \\(score)")
    case .updated(let score):
        print("High score updated: \\(score)")
    case .deleted(let score):
        print("High score removed: \\(score)")
    default:
        break
    }
}
﻿
Passo 3 – Applicare la Sicurezza con ACL e CLP
Panoramica
Back4App protegge i tuoi dati con ACL (Liste di Controllo degli Accessi) e CLP (Permessi a Livello di Classe). Usali per definire regole di lettura/scrittura a livello di oggetto o di classe.
﻿
Permessi a Livello di Classe
Vai al Database, scegli una classe (ad esempio, GameScore).
Clicca su “Sicurezza” o “Permessi a Livello di Classe”.
Imposta chi può leggere, scrivere o eliminare (ad esempio, solo utenti autenticati).
ACL in Codice
Swift
var gameScore = GameScore()
gameScore.score = 500
// Restrict read/write to only the current user
var acl = ParseACL()
if let user = try? await User.current() {
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)
}
gameScore.ACL = acl
var gameScore = GameScore()
gameScore.score = 500
// Restrict read/write to only the current user
var acl = ParseACL()
if let user = try? await User.current() {
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)
}
gameScore.ACL = acl
﻿
Passo 4 – Scrivere Funzioni di Cloud Code
Perché Cloud Code?
Il Cloud Code ti consente di trasferire la logica critica dal tuo client a codice sicuro lato server. Questo è ottimo per le regole aziendali, le convalide dei dati o le integrazioni di terze parti senza esporre segreti nella tua app tvOS.
Esempio di Funzione
Nel tuo main.js:
JS
Parse.Cloud.define("awardBonus", async (request) => {
  const { objectId, bonus } = request.params;
  const query = new Parse.Query("GameScore");
  const gameScore = await query.get(objectId, { useMasterKey: true });
  gameScore.increment("score", bonus);
  await gameScore.save(null, { useMasterKey: true });
  return gameScore;
});
Parse.Cloud.define("awardBonus", async (request) => {
  const { objectId, bonus } = request.params;
  const query = new Parse.Query("GameScore");
  const gameScore = await query.get(objectId, { useMasterKey: true });
  gameScore.increment("score", bonus);
  await gameScore.save(null, { useMasterKey: true });
  return gameScore;
});
﻿
Distribuzione
Back4App CLI:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
o usa il Back4App Dashboard → Cloud Code → Functions → main.js.
Chiamata da Swift
Swift
import ParseSwift

func awardBonusScore(objectId: String, bonus: Int) async {
    do {
       let result = try await ParseCloud.callFunction("awardBonus", with: [
         "objectId": objectId,
         "bonus": bonus
       ])
       print("Updated score: \\(result)")
    } catch {
       print("Error awarding bonus: \\(error)")
    }
}
import ParseSwift

func awardBonusScore(objectId: String, bonus: Int) async {
    do {
       let result = try await ParseCloud.callFunction("awardBonus", with: [
         "objectId": objectId,
         "bonus": bonus
       ])
       print("Updated score: \\(result)")
    } catch {
       print("Error awarding bonus: \\(error)")
    }
}
﻿
Moduli NPM
All'interno del tuo package.json, aggiungi dipendenze:
JSON
{
  "dependencies": {
    "axios": "^0.27.0"
  }
}
{
  "dependencies": {
    "axios": "^0.27.0"
  }
}
﻿
Poi richiedili o importali in main.js per usarli nel Cloud Code.
Passo 5 – Configurazione dell'Autenticazione
Autenticazione Utente in Back4App
Le app tvOS spesso necessitano di sincronizzazione dei dati utente o accesso. ParseUser di Parse fornisce registrazione sicura, accesso, sessioni e accesso basato su ruoli.
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Essential
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String: [String: String]?]?
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Essential
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String: [String: String]?]?
}
﻿
Registrati / Accedi
Swift
func signUpUser() async {
    var newUser = User()
    newUser.username = "tvUser"
    newUser.password = "secret"
    newUser.email = "[email protected]"
    do {
        try await newUser.signUp()
        print("Sign-up successful.")
    } catch {
        print("Error signing up: \\(error)")
    }
}

func loginUser() async {
    do {
        let loggedIn = try await User.login(username: "tvUser", password: "secret")
        print("Logged in as: \\(loggedIn.username ?? "")")
    } catch {
        print("Login error: \\(error)")
    }
}
func signUpUser() async {
    var newUser = User()
    newUser.username = "tvUser"
    newUser.password = "secret"
    newUser.email = "user@example.com"
    do {
        try await newUser.signUp()
        print("Sign-up successful.")
    } catch {
        print("Error signing up: \\(error)")
    }
}

func loginUser() async {
    do {
        let loggedIn = try await User.login(username: "tvUser", password: "secret")
        print("Logged in as: \\(loggedIn.username ?? "")")
    } catch {
        print("Login error: \\(error)")
    }
}
﻿
Accesso Sociale
Configura Accesso con Facebook o Apple. Quindi collega gli account:
Swift
try await user.link(with: .apple(idToken: "TOKEN", rawNonce: "NONCE"))
try await user.link(with: .apple(idToken: "TOKEN", rawNonce: "NONCE"))
﻿
Passo 6 – Gestione dello Storage dei File
Impostazione dello Storage dei File
Carica immagini utente, replay di giochi o risorse dell'app utilizzando ParseFile:
Swift
let fileData = Data(...) // e.g. image bytes
let file = ParseFile(name: "preview.png", data: fileData)
do {
    let savedFile = try await file.save()
    print("File uploaded: \\(savedFile.url)")
} catch {
    print("Error uploading file: \\(error)")
}
let fileData = Data(...) // e.g. image bytes
let file = ParseFile(name: "preview.png", data: fileData)
do {
    let savedFile = try await file.save()
    print("File uploaded: \\(savedFile.url)")
} catch {
    print("Error uploading file: \\(error)")
}
﻿
Esempio
Allega file agli oggetti:
Swift
struct GameMedia: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var screenshot: ParseFile?
}
struct GameMedia: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var screenshot: ParseFile?
}
﻿
Considerazioni sulla Sicurezza
Utilizza CLP o ACL per proteggere i riferimenti ai file. L'URL diretto di un file può essere accessibile pubblicamente a meno che tu non abiliti Sicurezza dei File.
Passo 7 – Verifica Email e Reimpostazione Password
Panoramica
La verifica dell'email aiuta a confermare la proprietà dell'account email da parte dell'utente. La reimpostazione della password offre un modo sicuro e user-friendly per riacquistare l'accesso all'account.
Configurazione del Dashboard di Back4App
Nella tua app → Impostazioni App → Email
Abilita la verifica dell'email o Reimpostazione password.
Personalizza i modelli di email.
Implementazione del codice
Swift
func requestPasswordReset(for email: String) async {
    do {
        try await User.passwordReset(email: email)
        print("Password reset link sent.")
    } catch {
        print("Error requesting password reset: \\(error)")
    }
}
func requestPasswordReset(for email: String) async {
    do {
        try await User.passwordReset(email: email)
        print("Password reset link sent.")
    } catch {
        print("Error requesting password reset: \\(error)")
    }
}
﻿
Passo 8 – Pianificazione dei compiti con Cloud Jobs
Cloud Jobs
Automatizza compiti ricorrenti, come la pulizia dei dati obsoleti o l'invio di aggiornamenti mensili:
JS
Parse.Cloud.job("cleanupOldScores", async (request) => {
  const now = new Date();
  const thirtyDaysAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);
  const query = new Parse.Query("GameScore");
  query.lessThan("createdAt", thirtyDaysAgo);
  const oldScores = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldScores, { useMasterKey: true });
  return `Deleted ${oldScores.length} old scores.`;
});
Parse.Cloud.job("cleanupOldScores", async (request) => {
  const now = new Date();
  const thirtyDaysAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);
  const query = new Parse.Query("GameScore");
  query.lessThan("createdAt", thirtyDaysAgo);
  const oldScores = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldScores, { useMasterKey: true });
  return `Deleted ${oldScores.length} old scores.`;
});
﻿
Nel Back4App Dashboard → Impostazioni App → Impostazioni Server → Compiti in background, pianifica “cleanupOldScores” per essere eseguito quotidianamente.
Pianificazione di un Cloud Job
﻿
Passo 9 – Integrazione dei Webhook
Definizione
I Webhook consentono alla tua app Back4App di inviare eventi a servizi esterni. Questo potrebbe includere l'invio di notifiche a Slack, aggiornamenti di pagamento a Stripe o dati analitici al tuo server.
Configurazione
Nel tuo Back4App Dashboard, vai su Altro → WebHooks → Aggiungi Webhook. Specifica un endpoint (come https://myserver.com/webhook-endpoint) e i trigger (aggiornamenti di oggetti, nuovi record, ecc.).
Aggiunta di un Webhook
﻿
Esempio
Notifica Slack quando viene creato un nuovo punteggio alto:
JS
Parse.Cloud.afterSave("GameScore", async (request) => {
  const score = request.object.get("score");
  await sendToSlack(`A new high score of ${score} was posted!`);
});
Parse.Cloud.afterSave("GameScore", async (request) => {
  const score = request.object.get("score");
  await sendToSlack(`A new high score of ${score} was posted!`);
});
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Dove Trovarlo
L' App di Amministrazione di Back4App è un dashboard intuitivo, centrato sul modello per gestire i dati, eseguire operazioni CRUD o modificare classi—senza necessità di query dirette al database.
Abilitalo tramite Dashboard dell'App → Altro → App di Amministrazione.
Abilita l'App di Amministrazione
﻿
Caratteristiche
Una volta abilitato, puoi invitare membri del team o clienti a gestire i dati, controllare i log o regolare le notifiche push—essenzialmente dando loro un portale diretto al backend della tua app tvOS.
Conclusione
Seguendo questo tutorial completo, hai:
Creato un backend sicuro per la tua app tvOS utilizzando Back4App.
Configurato un database con classi, tipi di dati e relazioni.
Impostato query in tempo reale per riflettere cambiamenti immediati.
Applicato sicurezza tramite ACL e CLP.
Implementato Cloud Code per logica aziendale personalizzata e integrazioni.
Abilitato autenticazione con verifica email e reset della password.
Gestito caricamenti di file con controlli di sicurezza opzionali.
Pianificato Cloud Jobs per compiti di routine.
Utilizzato webhook per integrare servizi esterni.
Esplorato il Pannello di Amministrazione per gestire e monitorare i dati.
Ora sei ben attrezzato per costruire esperienze Apple TV ricche e di alta qualità. La tua app è costruita su una solida base—goditi il passaggio delle tue idee per app tvOS nella realtà!
Prossimi Passi
Affina la tua interfaccia tvOS: Incorpora navigazione basata sul focus, flussi utente per schermi grandi e le migliori pratiche dell'App Store.
Migliora la sicurezza: Aggiungi ACL basate sui ruoli, autenticazione a più fattori o crittografia avanzata.
Approfondisci le tue competenze: Esplora funzionalità Parse Swift più avanzate come la memorizzazione nella cache offline o analisi personalizzate.
Controlla la documentazione ufficiale: Documenti Back4App e Documenti Apple tvOS per una conoscenza più approfondita.
Monetizzazione: Considera abbonamenti o pay-per-view per espandere il potenziale del tuo business di streaming.
Con le basi di questa guida, puoi continuare a innovare e integrare nuove funzionalità. Buona fortuna nel portare la tua app tvOS al livello successivo!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come creare un backend per WatchOS?
AVANTI IL PROSSIMO
Come costruire un backend per MacOS?