Schnellstarter
Wie man ein Backend für tvOS erstellt?

42min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für tvOS-Apps mit Back4App erstellt. 
Wir werden die Integration wesentlicher Back4App-Funktionen behandeln – wie Datenbankverwaltung, Cloud-Code-Funktionen, REST- und GraphQL-APIs, Benutzerauthentifizierung und Echtzeit (Live-Abfragen) – um ein sicheres, skalierbares Backend zu erstellen, das nahtlos mit Ihrer Apple TV-App kommuniziert, die mit dem Parse Swift SDK erstellt wurde.
Sie werden sehen, wie die optimierte Umgebung von Back4App und die schnelle Einrichtung die Zeit im Vergleich zur manuellen Konfiguration von Servern und Datenbanken drastisch reduzieren.
Unterwegs werden Sie praktische Erfahrungen mit wichtigen Funktionen sammeln, einschließlich fortschrittlicher Sicherheitsfunktionen, Planung von Cloud-Jobs und Webhook-Integrationen.
Am Ende dieses Tutorials sind Sie bereit, diese grundlegende Struktur in eine produktionsbereite tvOS-App zu erweitern oder benutzerdefinierte Logik und Drittanbieter-APIs einfach einzufügen. Dieser Leitfaden hilft auch dabei, eine hohe Qualität der Benutzererfahrung auf Apple TV, zu gewährleisten, indem Sie Ihr Xcode-Projekt und Ihr vorhandenes iOS-Entwicklungswissen nutzen.
Voraussetzungen
Um dieses Tutorial abzuschließen, benötigen Sie:
Ein Back4App-Konto und ein neues Back4App-Projekt
Erste Schritte mit Back4app.
Wenn Sie kein Konto haben, können Sie eines kostenlos erstellen. Befolgen Sie die obige Anleitung, um Ihr Projekt vorzubereiten.
Xcode (neueste stabile Version) installiert
Sie werden Ihre tvOS-App mit Swift oder SwiftUI erstellen. Stellen Sie sicher, dass Sie die aktuellste Version von Xcode aus dem Mac App Store haben.
Parse Swift SDK
Richten Sie das Parse Swift SDK ein, um Ihre tvOS-App zu verbinden.
Vertrautheit mit Swift und grundlegenden iOS/tvOS-Entwicklungskonzepten
Wenn Sie neu bei Apple TV sind, überprüfen Sie die Apple tvOS-Dokumentation oder ein Anfänger-Tutorial zuerst.
Stellen Sie sicher, dass Sie alle diese Voraussetzungen erfüllt haben, bevor Sie beginnen. Ihr Back4App-Projekt sollte bereit sein und ein lokales tvOS Xcode-Projekt eingerichtet sein, um Ihnen das Folgen zu erleichtern.
Schritt 1 – Erstellen eines neuen Projekts auf Back4App und Verbindung herstellen
Ein neues Projekt erstellen
Der erste Schritt beim Erstellen Ihres tvOS-App-Backends auf Back4App besteht darin, ein neues Projekt zu erstellen. Wenn Sie dies noch nicht getan haben, folgen Sie diesen Schritten:
Melden Sie sich bei Ihrem Back4App-Konto an.
Klicken Sie auf die Schaltfläche „Neue App“ in Ihrem Back4App-Dashboard.
Geben Sie Ihrer App einen Namen (z. B. „tvOS-Backend-Tutorial“).
﻿
Sobald das Projekt erstellt ist, sehen Sie es in Ihrem Back4App-Dashboard aufgelistet. Dieses neue Back4App-Projekt ist der Kern aller Backend-Konfigurationen, die in diesem Tutorial behandelt werden.
Verbinden Sie das Parse Swift SDK
Back4App nutzt Parse zur Handhabung von Datenspeicherung, Benutzerauthentifizierung, Echtzeitfunktionen und mehr. Um Ihre tvOS-App mit Back4App zu verbinden, installieren und konfigurieren Sie das Parse Swift SDK in Ihrem Xcode-Projekt.
Holen Sie sich Ihre Parse-Schlüssel:
Gehen Sie in Ihrem Back4App-Dashboard zu „App-Einstellungen“ oder „Sicherheit & Schlüssel“, um Ihre Anwendungs-ID und Client-Schlüssel. Sie sehen auch die Parse-Server-URL—gewöhnlich https://parseapi.back4app.com.
﻿
Installieren Sie das Parse Swift SDK in Ihrem tvOS-Projekt:
Swift Package Manager (Empfohlen)
Wählen Sie in Xcode Datei → Pakete hinzufügen.
Geben Sie die Parse Swift GitHub-URL ein: https://github.com/netreconlab/Parse-Swift.git
Wählen Sie die entsprechende Version oder den Hauptzweig.
CocoaPods
Wenn Sie CocoaPods bevorzugen, fügen Sie Folgendes zu Ihrer Podfile hinzu:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Führen Sie dann pod install aus.
Initialisieren Sie Parse in Ihrem AppDelegate oder @main Struktur:
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()
        }
    }
}
﻿
Dies stellt sicher, dass Ihre tvOS-App so konzipiert ist, dass sie mit dem Back4App-Backend kommuniziert, sodass Sie Daten speichern, Abfragen ausführen, Benutzer authentifizieren und mehr können.
Schritt 2 – Datenbank einrichten
Erstellen eines Datenmodells
Mit Ihrer tvOS-App, die jetzt mit Back4App verbunden ist, können Sie Daten erstellen und verwalten. In Parse Swift definieren Sie ParseObject Strukturen:
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?
}
﻿
Sie können auch manuell Klassen in Ihrem Back4App-Dashboard definieren:
Gehen Sie zu “Datenbank” in der Back4App-Konsole.
Erstellen Sie eine neue Klasse (z.B. “GameScore”).
Fügen Sie relevante Spalten hinzu (Punktzahl, Spielername usw.).
Neue Klasse erstellen
﻿
Erstellen eines Datenmodells mit dem KI-Agenten
Der KI-Agent von Back4App kann automatisch Ihr Schema entwerfen:
Öffnen Sie den KI-Agenten in Ihrem Back4App-Dashboard.
Beschreiben Sie Ihr Modell (z.B. “Erstellen Sie eine ToDo-Klasse mit einem Titel und einem isCompleted-Feld”).
Anwenden und lassen Sie den KI-Agenten das Schema generieren.
﻿
Daten lesen und schreiben mit 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)")
    }
}
﻿
Daten lesen und schreiben mit 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
﻿
Daten lesen und schreiben mit 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
    }
  }
}
﻿
Arbeiten mit Live-Abfragen (optional)
Live-Abfragen können Echtzeit-Updates in Ihrer Apple TV-Schnittstelle ermöglichen—besonders nützlich für Mehrspieler- oder Bestenlisten-Apps.
Aktivieren Sie Live-Abfragen in den Servereinstellungen Ihrer App auf Back4App.
Initialisieren Sie ein Abonnement:
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
    }
}
﻿
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Überblick
Back4App sichert Ihre Daten mit ACLs (Zugriffskontrolllisten) und CLPs (Klassenebene Berechtigungen). Verwenden Sie sie, um Lese-/Schreibregeln auf Objekt- oder Klassenebene zu definieren.
﻿
Klassenebene Berechtigungen
Gehe zur Datenbank, wähle eine Klasse (z.B. GameScore).
Klicke auf “Sicherheit” oder “Klassenebene Berechtigungen”.
Setze, wer lesen, schreiben oder löschen kann (z.B. nur authentifizierte Benutzer).
ACLs im Code
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
﻿
Schritt 4 – Schreiben von Cloud-Code-Funktionen
Warum Cloud-Code?
Cloud-Code ermöglicht es Ihnen, kritische Logik von Ihrem Client auf sicheren serverseitigen Code auszulagern. Dies ist großartig für Geschäftsregeln, Datenvalidierungen oder Integrationen von Drittanbietern, ohne Geheimnisse in Ihrer tvOS-App offenzulegen.
Beispiel-Funktion
In Ihrer 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;
});
﻿
Bereitstellung
Back4App CLI:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
oder verwenden Sie das Back4App Dashboard → Cloud Code → Functions → main.js.
Aufruf von 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)")
    }
}
﻿
NPM-Module
Fügen Sie in Ihrer package.json, Abhängigkeiten hinzu:
JSON
{
  "dependencies": {
    "axios": "^0.27.0"
  }
}
{
  "dependencies": {
    "axios": "^0.27.0"
  }
}
﻿
Dann fordern oder importieren Sie sie in main.js um sie im Cloud Code zu verwenden.
Schritt 5 – Authentifizierung konfigurieren
Benutzerauthentifizierung in Back4App
tvOS-Apps benötigen oft Benutzerdaten-Synchronisierung oder Anmeldung. Parse’s ParseUser bietet sichere Registrierung, Anmeldung, Sitzungen und rollenbasierte Zugriffe.
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]?]?
}
﻿
Registrieren / Anmelden
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)")
    }
}
﻿
Soziale Anmeldung
Konfigurieren Sie Facebook oder Apple Anmeldung. Dann Konten verknüpfen:
Swift
try await user.link(with: .apple(idToken: "TOKEN", rawNonce: "NONCE"))
try await user.link(with: .apple(idToken: "TOKEN", rawNonce: "NONCE"))
﻿
Schritt 6 – Umgang mit Dateispeicher
Einrichten des Dateispeichers
Laden Sie Benutzerbilder, Spielwiederholungen oder App-Ressourcen hoch mit 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)")
}
﻿
Beispiel
Dateien an Objekte anhängen:
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?
}
﻿
Sicherheitsüberlegungen
Verwenden Sie CLPs oder ACLs, um Dateireferenzen zu sichern. Eine direkte URL einer Datei kann öffentlich zugänglich sein, es sei denn, Sie aktivieren Dateisicherheit.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Übersicht
Die E-Mail-Verifizierung hilft, den Besitz von E-Mail-Konten durch den Benutzer zu bestätigen. Die Passwortzurücksetzung bietet eine sichere, benutzerfreundliche Möglichkeit, den Zugriff auf das Konto wiederzuerlangen.
Back4App Dashboard-Konfiguration
In Ihrer App → App-Einstellungen → E-Mail
E-Mail-Verifizierung oder Passwortzurücksetzung aktivieren.
E-Mail-Vorlagen anpassen.
Code-Implementierung
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)")
    }
}
﻿
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Cloud-Jobs
Automatisieren Sie wiederkehrende Aufgaben, wie das Bereinigen alter Daten oder das Versenden monatlicher Updates:
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.`;
});
﻿
Im Back4App Dashboard → App-Einstellungen → Servereinstellungen → Hintergrundjobs, planen Sie „cleanupOldScores“, um täglich ausgeführt zu werden.
Planung eines Cloud-Jobs
﻿
Schritt 9 – Integration von Webhooks
Definition
Webhooks ermöglichen Ihrer Back4App-App, Ereignisse an externe Dienste zu senden. Dies könnte das Senden von Benachrichtigungen an Slack, Zahlungsupdates an Stripe oder Analysedaten an Ihren Server sein.
Konfiguration
Gehen Sie in Ihrem Back4App Dashboard zu Mehr → WebHooks → Webhook hinzufügen. Geben Sie einen Endpunkt an (wie https://myserver.com/webhook-endpoint) und die Trigger (Objektaktualisierungen, neue Datensätze usw.).
Hinzufügen eines Webhooks
﻿
Beispiel
Benachrichtigen Sie Slack, wenn ein neuer Highscore erstellt wird:
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!`);
});
﻿
Schritt 10 – Erkundung des Back4App Admin Panels
Wo man es findet
Die Back4App Admin App ist ein benutzerfreundliches, modellzentriertes Dashboard zur Verwaltung von Daten, zur Durchführung von CRUD oder zur Bearbeitung von Klassen—ohne direkte Datenbankabfragen.
Aktivieren Sie es über App Dashboard → Mehr → Admin App.
Admin App aktivieren
﻿
Funktionen
Sobald aktiviert, können Sie Teammitglieder oder Kunden einladen, um Daten zu verwalten, Protokolle zu überprüfen oder Push-Benachrichtigungen anzupassen—im Wesentlichen geben Sie ihnen ein direktes Portal zum Backend Ihrer tvOS-App.
Fazit
Indem Sie dieses umfassende Tutorial befolgt haben, haben Sie:
Einen sicheren Backend für Ihre tvOS-App mit Back4App erstellt.
Eine Datenbank mit Klassen, Datentypen und Beziehungen konfiguriert.
Echtzeitabfragen eingerichtet, um sofortige Änderungen widerzuspiegeln.
Sicherheit durch ACLs und CLPs angewendet.
Cloud Code für benutzerdefinierte Geschäftslogik und Integrationen implementiert.
Authentifizierung mit E-Mail-Verifizierung und Passwortzurücksetzungen aktiviert.
Datei-Uploads mit optionalen Sicherheitskontrollen behandelt.
Cloud-Jobs für Routineaufgaben geplant.
Webhooks verwendet, um mit externen Diensten zu integrieren.
Das Admin-Panel erkundet, um Daten zu verwalten und zu überwachen.
Sie sind jetzt gut gerüstet, um reichhaltige, hochwertige Apple TV-Erlebnisse zu schaffen. Ihre App ist gebaut auf einem starken Fundament—genießen Sie es, Ihre tvOS-App-Ideen in die Realität umzusetzen!
Nächste Schritte
Verfeinern Sie Ihre tvOS-Benutzeroberfläche: Integrieren Sie fokusbasierte Navigation, Benutzerflüsse für große Bildschirme und App Store Best Practices.
Sicherheit verbessern: Fügen Sie rollenbasierte ACL, Multi-Faktor-Authentifizierung oder erweiterte Verschlüsselung hinzu.
Vertiefen Sie Ihre Fähigkeiten: Erkunden Sie fortgeschrittenere Parse Swift-Funktionen wie Offline-Caching oder benutzerdefinierte Analysen.
Offizielle Dokumente ansehen: Back4App-Dokumente und Apple tvOS-Dokumente für tiefere Kenntnisse.
Monetarisierung: Erwägen Sie Abonnements oder Pay-per-View, um das Potenzial Ihres Streaming-Geschäfts zu erweitern.
Mit den Grundlagen aus diesem Leitfaden können Sie weiterhin innovativ sein und neue Funktionen integrieren. Viel Glück, Ihre tvOS-App auf die nächste Stufe zu bringen!
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für WatchOS erstellt?
ALS NÄCHSTES
Wie man ein Backend für MacOS erstellt?