tvos-tutorial

Im tvOS Tutorial lernst Du erste Grundlagen von Apples neuer AppleTV Plattform kennen. Hier steckt unheimlich viel Potential, das bisher noch völlig unterschätzt wird. Für jeden Anbieter von Medieninhalten, gibt es hier einen direkten Kanal in das Wohnzimmer der Zielgruppe. Egal ob YouTuber, TV-Sender, Bildungseinrichtung oder Filmstudio. Im ersten Beispiel erstellst Du eine native App mit Swift, im zweiten Teil erzeugst Du mit dem neuen TVMLKit mittels TVML und TVJS eine Client/Server App.

tvOS Grundlagen

Apps für die AppleTV Plattform entwickeln

Die tvOS Plattform bietet Bekanntes, aber auch eine Reihe neuer Möglichkeiten. Gerade das UIKit und viele iOS-Frameworks können in nativen Apps weiter verwendet werden. Hier muss also nicht von Grund auf neu gelernt werden. Andersrum kannst Du Wissen das Du hier erlangst, auch schnell auf iPhone und iPad Apps übertragen.

Neu ist unter anderem das TVMLKit, in dem die Oberflächen der Apps über die neuen Sprachen TVML und TVJS geschrieben werden. Dabei handelt es sich um eine Mischung aus HTML und XML bzw. eine Erweiterung von JavaScript. Speziell für medienintensive Apps mit Streamingangeboten eine Alternative. Sie können so sehr schnell umgesetzt werden.

Eine weitere Herausforderung ist die maximale Größe von 200MB pro App. Damit können wirklich nur essentielle Bestandteile direkt mitgeliefert werden. Gute Nachricht jedoch: bis zu 20GB können als sogenannte On-Demand Resource auf Abruf heruntergeladen werden.

Auch das Bedienkonzept ist wegen der fehlenden Touchscreens grundsätzlich anders. Maßgeblich dafür verantwortlich ist die sogenannte Focus Engine.

Die Focus Engine

Das tvOS Bedienkonzept mit der überarbeiteten Remote ist gelungen. Das integrierte Touchpad funktioniert zuverlässig. Auch die Steuerung geht damit wirklich sehr intuitiv. Selbst mein Sohn (7) kam damit auf Anhieb gut zurecht. Möglich macht dies die Focus Engine.

Gerade bei nativen Apps stehen viele Elemente der iOS-Plattform zur Verfügung. Die bisherige Auswahl per Touchscreen ist am Fernseher nicht praktikabel. Die Focus Engine bestimmt welches View-Elemente wie zum Beispiel ein Button, Collection View Items oder ähnliches gerade den Fokus hat. Es ist ausgewählt und wird deutlich hervorgehoben. Wird auf der Fernbedingung nun geklickt, wird das gewählte Element aktiviert:

focusengine

Die Idee ist relativ einfach, aber ebenso gut umgesetzt. Grundsätzlich funktioniert in den meisten Situationen gerade die Bestimmung und der Wechsel des Fokus einwandfrei. In manchen Situationen muss über den Code nachgeholfen werden.

Limits für Apps

Sehr radikal erscheint zunächst die maximale Größe von 200MB, die für tvOS-Apps gilt. Immerhin sind iOS-Apps mit maximal 4GB um ein vielfaches größer. In den meisten Fällen wird ein AppleTV Gerät an einer zuverlässigen Internetanbindung im heimischen Wohnzimmer betrieben. Apps auf iPhones und iPads werden häufiger sogar über die unzuverlässige mobile Anschluss installiert. Wieso also dieser Schritt? Die Antwort sind On-Demand Resources.

On-Demand Resources

Neben 200MB in der Basisinstallation können tvOS-Apps nun zusätzlich 20GB an Ressourcen mitbringen, die über den NSBundleResourceRequest nachgeladen werden können! Die sogenannten On-Demand Resources werden einfach heruntergeladen, wenn sie gebraucht werden. Im besten Fall erkennst Du als Entwickler die Situation sogar schon vorab. Dann kannst Du Ressourcen die in Kürze benötigt werden schon intelligent vorab herunterladen.

Stell es Dir an einem Spiel mit 20 verschiedenen Leveln vor. Jedes hat genau 100MB. Im klassischen Ansatz wurden 2GB heruntergeladen. Über On-Demand Resources wird nur das erste Level direkt nach der Installation heruntergeladen. Beginnt der Benutzer das Spiel, kann im Hintergrund bereits das zweite Level heruntergeladen werden. Und so weiter.

Es gibt sogar noch mehr Vorteile. Ist das System voll können Ressourcen gelöscht werden. Da geht Apple sehr intelligent vor und versucht die am längsten ungenutzten Ressourcen zu entfernen. Wenn sie erneut benötigt werden, stehen sie ja auch jederzeit wieder zum Download bereit!

tvOS Tutorial: Apps mit Swift entwickeln

Das Projekt erzeugen

Im ersten Schritt wird das tvOS-Projekt erzeugt. Wenn Du schon einmal mit Xcode gearbeitet hast, kennst Du die Auswahl der Vorlagen. Hier musst du links in der Gruppe tvOS unter Application die Single View Application wählen:

Screen Shot 2016-03-10 at 08.40.56

Wer meine Kurse oder sonstige Tutorials verfolgt, weiß das ich – mit Ausnahme bei Spielen – immer damit beginne. Mit Next geht es zur Eingabe des Projektnamens, Deinem Organization Name und ähnlichem. Wird die App nicht veröffentlicht, ist der Identifier nicht so wichtig. Wenn aber die App in den Store soll, oder z.B. CloudKit verwendet wird, wählst Du als Organization Identifier Deinen Domainnamen in der Reverse-Notation. Die Top-Level-Domain kommt an erste Stelle, danach erst der Domainname selbst. Gehört Dir die URL codingtutor.de, ist Dein Identifier entsprechend de.codingtutor. Bei janbrinkmann.de ist Dein Identifier de.janbrinkmann:

Screen Shot 2016-03-10 at 08.52.54

Im anschließenden Dialog musst Du nur noch den Speicherort wählen und erneut bestätigen. Anschließend öffnet sich Dein tvOS-Projekt.

Hallo Welt

Bevor es mit der Entwicklung Deiner ersten tvOS-App los geht, prüfst Du nun ob Xcode das Projekt kompilieren und der Simulator alles fehlerfrei ausführen kann. Wähl links im Projekt Navigator dafür zuerst die Datei Main.Storyboard:

Screen Shot 2016-03-10 at 09.02.44

Es öffnet sich nun ein Storyboard, in dem bereits ein View Controller hinterlegt ist. Im Gegensatz zu iOS-Projekten nimmt der relativ viel Platz ein, was an der Auflösung von 1920×1080 liegt. Mit der Kombination ⌘ + Minus kannst Du den Zoom verändern und hast eine bessere Übersicht. Bei tvOS Projekten gerade mit mehreren Szenen später sehr praktisch. Um nun Elemente zu hinterlegen, musst Du in die normale Zoomstufe zurückkehren. Das geschieht per Doppelklick auf den View Controller.

Jetzt ziehst Du aus der Object Library unten rechts ein Label per Drag & Drop auf den View Controller:

Screen Shot 2016-03-10 at 09.16.28

Wenn Du diese Seitenleiste nicht angezeigt bekommst, musst Du oben rechts die Utilities Seitenleiste aktivieren:

Screen Shot 2016-03-10 at 09.18.55

Weiter geht es mit dem Label. Hier schreiben wir das obligatorische “Hallo Welt” herein. Zum editieren einfach doppelt auf das UILabel klicken:

Screen Shot 2016-03-10 at 09.41.46

Dann geht es um die Position in der View. Theoretisch ist es egal wo das Label hinterlegt ist, aber nun kannst Du bereits ein erstes Feature von Xcode kennenlernen. Während Du Elemente verschiebst, erscheinen zwischendurch Hilfslinien. Sie helfen Dir in diesem Fall das Label mittig zu hinterlegen:

Screen Shot 2016-03-10 at 09.47.08 (2)

Jetzt kannst Du das Projekt ausführen und den Simulator starten. Dazu nutzt Du einfach den Button oben links. Achte darauf das als Gerät der Simulator Apple TV 1080p ausgewählt ist, wie im Screenshot zu sehen:

Screen Shot 2016-03-10 at 09.50.46

Wenn alles funktioniert hat, zeigt sich nun der Simulator mit der gestarteten tvOS-App:

Screen Shot 2016-03-10 at 09.52.22

Gerade bei der Entwicklung ist ggf. ein so großes Fenster nicht immer sehr praktisch. Über das Menü Window -> Scale kannst Du die Größe auch auf 75% oder 50% setzen. Gerade bei einem etwas kleineren Monitor etwas übersichtlicher. Wenn alles funktioniert, bist Du bereit für das Beispielprojekt.

AppleTV Apps entwickeln: der umfassende Kurs

Der schnellste Weg auf dem Du das riesige Potential der tvOS Plattform auszunutzen kannst.

Hier geht es zu den AppleTV Kursen

Das Ziel: die 1×1 App

Die native Swift App in diesem Tutorial stellt dem Benutzer einfache Rechenaufgaben. Es werden zwei zufällige Zahlen addiert und zwei Antworten vorgeschlagen, eine jeweils korrekt und eine jeweils falsch:

Simulator Screen Shot 10 Mar 2016 13.37.41

Nach Auswahl einer der beiden Optionen wird die Eingabe ausgewertet. Die Rückmeldung an den Benutzer wird über einen UIAlertController angezeigt. Entweder war das Ergebnis korrekt:

Simulator Screen Shot 10 Mar 2016 13.42.41

Oder es war falsch:

Simulator Screen Shot 10 Mar 2016 13.42.47

Beide Szenarien sind technisch sehr ähnlich. Letzter Schritt ist der Abschluss des Workflows. Wenn der Benutzer mit “OK” bestätigt, wird eine neue Rechenaufgabe generiert und die Logik startet neu.

Die UILabel hinterlegen

Ändere den Text im “Hallo Welt”-Label in dem Du doppelt darauf klickst und dann die Aufforderung an den Benutzer hinterlegst: “Lös die folgende Aufgabe:”

Screen Shot 2016-03-10 at 14.02.44

Anschließend bestätigst Du mit Enter und schiebst das Label in den oberen Bereich. Auch hier zeigen Dir die blauen Hilfslinien wenn das Label mittig positioniert ist. Aus der Object Library wird nun per Drag&Drop ein zweites Label eingefügt. Darin wird später die eigentliche Aufgabe angezeigt:

Screen Shot 2016-03-10 at 14.05.40

Was Du in das untere Label schreibst, ist nicht so wichtig. Der Text wird ohnehin durch die App ersetzt. Ich habe hier eine Beispielaufgabe angegeben, da sofort klar ist wofür das Label später verwendet wird. Inhaltlich sind die Label ausreichend, aber wirklich nicht schön.

Gestaltung der Labels

Um sie etwas besser in den Stil der tvOS Plattform einzupassen, steigerst Du nun mit wenigen Handgriffen das Aussehen um ein vielfaches. Wähl dazu zunächst das obere Label und öffne rechts den Attribute Inspector.

Die schwarze Farbe passt nicht wirklich zu dem Hintergrund. Es trägt sehr stark auf. Mit einem dunklen Grau wirkt es angenehmer:

Screen Shot 2016-03-10 at 14.10.51

Noch wichtiger: Die Schriftart selbst (Font). Klick auf das “T” neben der bisherigen Schriftart und wähl “Title 3” unter der Gruppe “Text Styles”:

Screen Shot 2016-03-10 at 14.12.09

Mittels “Done” bestätigst Du nun die Auswahl. Evt. musst Du das Label noch etwas vergrößern, da nur Ausschnitte der Schrift zu sehen sind. Dazu sind die kleinen weißen Kästchen, die außen um das gewählte Label herum angezeigt werden, gedacht.

Schließlich positionierst Du das Label wieder mittig. Auch hier helfen die blauen Hilfslinien. Anschließend wählst Du das zweite Label, setzt hier ebenfalls die Farbe auf eine Graustufe und wählst als Schriftart nun “Body” unter den “Text Styles”. Anschließend muss das etwas vergrößert werden. Plan etwas mehr Platz ein, damit auch dreistellige Zahlen Platz finden. Zentrier das Label in der View und stell im Attribute Inspector das Alignment auf Center. Sieht schon ansprechender aus, oder?

Screen Shot 2016-03-10 at 14.18.18

Fehlen nur noch Buttons, damit der Benutzer wirklich eine Auswahl treffen kann.

Die Buttons hinzufügen

Jetzt ziehst Du per Drag&Drop zwei Buttons aus der Object Library in der Seitenleiste unten rechts ca. mittig in den View Controller. Wenn Du CMD (⌘) gedrückt hälst und nach einander die neuen Buttons anklickst, kannst Du sie gleichzeitig bewegen und wieder mit Hilfe der blauen Linien in der Mitte ablegen:

Screen Shot 2016-03-10 at 15.07.41

Erneut ist der Text der Buttons nicht so wichtig, da die eigentlichen Werte über den Code gesetzt werden.

Outlets erzeugen

Wenn Du bereits mit iOS gearbeitet hast, sind Dir IBOutlet und IBAction sicher ein Begriff. Beides wird hier auch benötigt:

  • ein Outlet für das Label mit der Aufgabe
  • je Button ein eigenes Outlet

Ein Outlet ist eine spezielle Variable, über die ein View Element im Quellcode angesprochen werden kann. Um sie zu erzeugen, musst Du gleichzeitig Dein Storyboard und die Klasse des Controllers sehen. Öffne den Assistent Editor über die Schaltfläche im Xcode Fenster oben rechts:

Screen Shot 2016-03-10 at 15.11.53

Nun hast Du im linken Bereich das Storyboard, im rechts Bereich sollte die Klasse ViewController geöffnet sein. Wähl zunächst das Label mit der Aufgabe aus. Dann drückst Du STRG bzw. CTRL, klickst das Label an und ziehst mit der Maus nach rechts zur Klasse ViewController. Es entsteht ein blauer Strich. Wenn Du innerhalb innerhalb der Klassendefinition bist, zeigt Dir Xcode den Hinweis “Insert Outlet or Outlet Connection”:

outlet-action-xcode

Dann kannst Du die Maus wieder loslassen. Es öffnet sich ein kleiner Dialog, der nach Details für das Outlet fragt:

Screen Shot 2016-03-10 at 15.18.31

Hier gibst Du den Namen ein, unter dem Dein Label im Quellcode ansprechbar ist. Ich wähle den Namen aufgabeLabel. Nun solltest Du das IBOutlet in Deiner Klasse finden:

Jetzt erzeugst Du auf gleichem Weg die Outlets für die beiden Buttons. Ich habe als Namen einfach button1 und button2 gewählt.

 

Actions erzeugen

Eine Action ist eine spezielle Methode. Sie wird aufgerufen wird wenn der Benutzer das verknüpfte View Element aktiviert. Outlets und Actions werden ganz ähnlich erstellt. Auch hier arbeitest Du wieder mit CTRL und Drag&Drop. Wähl den ersten Button, halte CTRL gedrückt und zieh wieder die Verbindung in die Klasse rechts:

action-xcode-storyboard

Dieses mal ist im Hinweis auch bereits die Action zu finden. Grund ist der UIButton. Für aktivierbare Elemente können Actions erstellt werden. Passive Elemente wie das UILabel bieten die Möglichkeit nicht. Wenn Du die Maus loslässt, begrüsst Dich der gleiche Dialog wie beim Outlet. Hier wählst Du oben bei “Connection” nun Action, bei Type UIButton und als Namen zum Beispiel auswahlGetroffen:

Screen Shot 2016-03-10 at 15.35.31

Anschließend bestätigst Du mittels “Connect” Deine Eingaben. Es entsteht eine neue Methode, die in etwa wie folgt aussieht:

Und der zweite Button? Du könntest den Prozess ebenso wiederholen und noch eine weitere Action erstellen. Das würde aber dem DRY-Prinzip (Don’t Repeat Yourself) widersprechen. Deshalb verbindest Du nun die Action auch mit dem anderen Button. Klick den kleinen runden Kreis vor IBAction an und verbinde ihn mit dem rechten Button:

action-connect-button

Die Action wird nun ausgeführt, wenn einer der beiden Buttons gewählt wird.

(HINWEIS: Wenn Du den Swift Code nicht in jedem Detail verstehst, empfehle ich Dir unbedingt die Swift 101 Training Serie)

Die Klasse ViewController

Der Assistent Editor wird vorerst nicht mehr benötigt. Stattdessen schaltest Du auf den Standard Editor um (links neben der Schaltfläche für den Assistent Editor). Gerade bei der Entwicklung ist mehr Platz übersichtlicher. Umgeschaltet auf die normale Ansicht? Dann öffne jetzt im Editor die Datei ViewController.swift. Darin ist der Quellcode des UIViewControllers, der dem Controller im Storyboard automatisch zugewiesen wurde.

Hier findest Du nun das Outlet für die Rechenaufgabe (aufgabeLabel) sowie die Outlets für die beiden Buttons (button1 und button2). Außerdem sind in der Klasse ViewController zwei Methoden hinterlegt. Das ist zum einen viewDidLoad, eine Methode die ausgeführt wird sobald die entsprechende View geladen wurde. Der optimale Einstiegspunkt für die Initialisierung der ersten Aufgabe! Außerdem findest Du didReceiveMemoryWarning, eine Methode die hier nun keine weitere Rolle spielt.

Bevor Du eine Aufgabe anzeigen kannst, muss die Aufgabe sowie die Lösung bestimmt werden.

Die Rechenaufgabe generieren

Die Rechenaufgabe wird nun in der Methode generateProblem erzeugt. Sie ist als private markiert, da sie nur in dieser Datei benötigt wird. Eine genaue Erklärung dazu findest Du auch im Videotutorial Access Control mit Swift: private, public & Co. Als Rückgabewert habe ich mich für einen Tuple entschieden, in dem eine Ganzzahl (das Ergebnis) und ein String (die Rechenaufgabe) enthalten sind:

In der Methode werden zunächst die beiden Summanden a und b zufällig erzeugt (siehe 1). Dazu wird ein Wert zwischen 0 und 9 generiert (der Maximalwert 10 wird nie erreicht) und dann jeweils der Wert eins hinzugerechnet. Es wird also eine Zahl zwischen eins und zehn generiert.

Anschließend wird das numerische Ergebnis in sum gespeichert. In der Zeichenkette msg wird schließlich die zu lösende Aufgabe zusammengesetzt (siehe 2). Beides zusammen wird dann in einem Tuple von der Methode zurückgegeben (siehe 3). Aber wie kommen die Werte nun in die Buttons und das Label?

AppleTV Apps entwickeln: der umfassende Kurs

Der schnellste Weg auf dem Du das riesige Potential der tvOS Plattform auszunutzen kannst.

Hier klicken und AppleTV Apps entwickeln

Das Interface aktualisieren

Die Methode generateProblem ist nicht ausreichend. Zum einen muss sie irgendwo aufgerufen werden. Außerdem müssen ja die generierten Werte auch irgendwie angezeigt werden. Dazu schlage ich eine weitere Methode vor – updateProblem:

Zunächst wird die Aufgabe generiert. Dazu rufst Du generateProblem auf (siehe 1). Dabei werden die Werte aus dem Tuple direkt einzelnen Variablen, antwort und aufgabe, zugewiesen.

Im zweiten Schritt wird die Aufgabe im Label angezeigt. Der sichtbare Text wird in einem UILabel in der Eigenschaft text gesetzt. Und genau das passiert in Schritt 2. Hier nutzt Du die Variable aufgabe (siehe 2).

Jetzt musst Du nur noch die Buttons anpassen. Um den Code nicht unnötig kompliziert zu gestalten, wird die numerische Antwort als Text gesetzt. Der String kann wieder in einen numerischen Wert umgewandelt werden. Die Aufgabe ist bei einem UIButton aber etwas aufwendiger als bei einem UILabel. Mit der Methode setTitle kann der Titel für verschiedene Zustände gesetzt werden. Ohne zu weit abzuschweifen – in diesem Fall ist der UIControlState Normal relevant. Der erste Button zeigt hier immer die richtige Lösung an, im zweiten Button wird jeweils eins hinzuaddiert. Siehe dazu Punkt 3 im Code oben.

Für den Schritt 4 ist nun noch eine Vorbereitung notwendig. Wenn im weiteren Verlauf die Frage beantwortet wird, muss das korrekte Ergebnis noch vorliegen. Deshalb speicherst Du dies in einer Eigenschaft (siehe 4). Die Eigenschaft gibt es bisher aber noch nicht und muss oben in der Klassendefinition erzeugt werden. Sie bekommt den Namen correctAnswer:

Das View Controller Objekt ist auch nach dem Aufruf der Methode updateProblem noch im Speicher. Deshalb bleibt auch das Ergebnis in der Eigenschaft correctAnswer abrufbar. Wird ein Button angeklickt, kannst Du darauf zugreifen und vergleichen.

Initialisierung: updateProblem aufrufen

Als aufmerksamer Leser fragst Du Dich nun, wie wird denn die Methode updateProblem aufgerufen? Sehr gut! Der optimale Punkt für die Initialisierung ist in diesem Fall die Methode viewDidLoad. Wenn die View erzeugt wurde, ruft tvOS genau diese Methode auf. Und da kannst Du Dich einhaken. Mit anderen Worten rufst Du updateProblem einfach in der Methode viewDidLoad auf:

Hier sind drei Aspekte wichtig. Zum Beispiel wird das Keyword override vor einer Methodendefinition hinterlegt, wenn die Methode einer Hauptklasse überschrieben wird. Da die Klasse ViewController von UIViewController abgeleitet wird und viewDidLoad in der Superklasse existiert, wird dies genau so sichtbar gemacht (siehe 1).

In der neuen Methode wird in der Regel die gleiche Methode der Hauptklasse aufgerufen. Die vorhandene Funktionalität wird einfach nur erweitert. Es gibt natürlich Ausnahmen, aber bis Du die selbst verstehst ist dieses Vorgehen unbedingt zu empfehlen (siehe auch 2).

Schließlich rufst Du updateProblem auf. Dadurch generierst Du die Aufgabe, aktualisierst das Interface und speicherst das Ergebnis für die Auswertung der Eingaben.

Auswerten der Eingaben

Das führt schließlich zur Verarbeitung der Eingaben in der  Methode auswahlGetroffen – die Action (IBAction) die weiter oben schon erzeugt wurde:

Im ersten Schritt liest Du aus dem Button den gesetzten Text. Die Konstante antwort enthält die Antwort als Zeichenkette. Die Konstante numeric wird schließlich erzeugt und der String in einen Int-Wert umgewandelt (siehe 1). Hier werden Optionals mittels Forced Unwrapping (dem Ausrufzeichen dahinter) “ausgepackt”, da unter anderem die Umwandlung von String zu Integer nicht immer funktioniert. In diesem Fall können wir uns jedoch darauf verlassen, da nur Ziffern im Text stehen.

Der zweite Schritt bereitet nun einen UIAlertController vor, der technisch unter tvOS und iOS nahezu identisch funktioniert. Die if-Bedingung prüft ob die gewählte Antwort mit der korrekten Antwort aus der Eigenschaft correctAnswer übereinstimmt. Entweder gibt es eine Erfolgsmeldung, oder aber einen Hinweis zur nicht korrekten Antwort (siehe 2).

Der UIAlertController wurde bisher aber nur vorbereitet. Im dritten Schritt wird nun noch ein “OK” Button hinzugefügt – egal ob die Antwort korrekt oder falsch war. Interessant ist hier die Closure-Funktion die als handler übergeben wird. Diese Funktion wird aufgerufen, wenn der Benutzer auf “OK” drückt. In dem Fall wird updateProblem erneut aufgerufen und somit eine neue Aufgabe erzeugt. Der Ablauf beginnt erneut (siehe 3).

Der Hinweis muss schließlich noch angezeigt werden. Dazu wird presentViewController aufgerufen und der neu erzeugte Alert Controller übergeben (siehe 4).

Die vollständige Klasse ViewController

Wenn ich in einem neuen Gebiet Tutorials lese, verstehe ich meist die Zusammenhänge besser wenn ich Codebeispiele im Gesamtkontext sehe. Darum hier noch einmal die vollständige Klasse ViewController:

Fazit

Herzlichen Glückwunsch. Damit hast Du Deine erste native tvOS-App mit Swift entwickelt! Wenn Du nun Lust auf mehr hast, findest Du übrigens noch viel mehr Beispiele in den Videotrainings rund um das AppleTV Apps entwickeln.

[freememberupgrade]

  • Das Xcode Beispielprojekt
  • Das tvOS Tutorial als eBook (33 Seiten!)
  • Übungsaufgaben inkl. Musterlösung

[/freememberupgrade]

[ds_preview]

Deine Upgrades

Beispielquellcode

Hier kannst Du das finale Projekt herunterladen

Download als eBook

Hier kannst Du das tvOS Tutorial als eBook herunterladen 

Übungsaufgaben inkl. Musterlösung

Drei Auswahlmöglichkeiten

Die erste Aufgabe besteht darin drei statt nur zwei Optionen anzubieten.

Bessere Alternativen

Das bisherige Schema versteht bereits mein kleiner Sohn schon nach der 3. oder 4. Aufgabe. Wenn die richtige Lösung immer an gleicher Stelle steht, ist das nicht sinnvoll. Die korrekten und falschen Ergebnisse werden nun per Zufall verteilt.

Musterlösungen

Die Musterlösung kannst Du in den Beispielprojekten nachvollziehen. Die Änderungen sind alle in der Klasse ViewController. Du findest die erweiterten Projekte hier:

Musterlösungen herunterladen

Schreib einen Kommentar

Your email address will not be published.