iOS mit Swift [Video Tutorials]

  1. letztes Jahr

    GLSS

    12 Dec 2015 Administrator

    [center]

    iOS mit Swift [Video Tutorials]

    [/center]

    Interfaces mit Autolayout

    Es gibt mittlerweile viele iOS-Geräte mit unterschiedlichen Auflösungen. Um jedem Nutzer gerecht zu werden, müssen Deine Apps überall ansprechend aussehen. Sie müssen auf den vorhanden Platz reagieren. Dazu bietet Apple im UiKit die sogenannten Autolayouts an. Du positionierst nicht mehr jedes Element auf den Pixel genau. Stattdessen legst Du Constraints fest. Die Beschreiben, wie Deine UI-Elemente anzuordnen sind. Zentriert in der aktuellen View? Der Abstand relativ zum oberen Rand beibehalten? Oder zum nächstgelegenen View-Element? Mit Autolayout-Constraints ein Kinderspiel.

    Gemeinsam legen wir das Interface für einen Umrechner fest. Die App wird als Universal-App sowohl auf dem iPhone als auch auf dem iPad nutzbar. Der Benutzer gibt in ein das UITextfield eine natürliche Zahl ein. Die App berechnet dann die Fakultät dieser Zahl (n!). Die Berechnung erfolgt über die Multiplikation aller natürlichen Zahlenvon eins bis einschließlich der genannten Zahl selbst. Die Fakultät von 3 ist also zum Beispiel sechs, also 1x2x3. Für die Ausgabe legen wir zwei Label fest, eines für die Aufgabe und ein weiteres für das Ergebnis. Die notwendige Logik wird in einem späteren Video vervollständigt.

    Konkret legen wir über Layout-Constraints Abstände fest, legen die Breite und Höhe fest und sorgen mit den Alignment Constraints für die gewünschte Ausrichtung (Horizontal Center in Container). Wir nutzen in Xcode die Storyboard Vorschau sowie den Pin- und den Align-Dialog. Du lernst außerdem einen einfachen Trick kennen, mit dem Du über eine UIView zwei Elemente wie UILabels oder UIButtons sehr einfach zentrieren kannst. Hinweis: Ohne diesen Trick ist es ziemlich umständlich.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    Swift 1.2: Neuerungen und automatische Migration mit Xcode

    Mit Swift 1.2 hat Apple einige Neuerungen rund um die die neue Sprache veröffentlich. Vieles passiert im Hintergrund oder bietet neue Möglichkeiten. Eine Anpassung wirkt sich aber unmittelbar auf Entwickler aus. Der bestehende Code wird dadurch ungültig. Ursache ist eine Änderung beim Casting von Objekten. Das Keyword “as” konnte vorab frei verwendet werden. Jetzt ist es streng an Optionals angelehnt. Dazu gibst Du als Entwickler das neue Objekt mit “as?” als Optional zurück. Alternativ kannst du mittels Optional-Unwrapping die Konvertierung erzwingen. Dazu verwendest Du als Keyword “as!”.

    Diese Änderung ist unglaublich simpel. Bei bestehenden Projekten und Quellcode hat sich allerdings durchaus Auswirkungen. Bei einzelnen Dateien sicher gar kein Aufwand etwas zu ändern. Wenn Du aber ein umfangreicheres Projekt geschrieben hast, kannst Du die Migration mit Xcode weitestgehend automatisch vornehmen. Ich zeige Dir im Video, wie das geht.

    Insgesamt hat die Version 1.2 von Swift natürlich auch viele positive Änderungen mitgebracht. Dazu gehört zum Beispiel eine verbesserte Geschwindigkeit! Bereits beim Übersetzen des Quellcodes ist das spürbar. Statt immer alle Dateien neu zu kompilieren, werden nur noch geänderte Dateien neu übersetzt. Hier spricht Apple von “incremental builds”. Auch zur Laufzeit ist die Performance in manchen Szenarien besser als bei Objective-C. Dieser Trend könnte sich in Zukunft fortsetzen, wenn noch mehr Teile der Standardbibliothek nativ in Swift vorliegen.

    Spannend sind auch die neuen if/let bindings und eine weitere Mikrooptimierungen. Insgesamt wurde auch das Zusammenspiel mit Objective-C noch weiter verbessert. Es ist deutlich spürbar, dass Apple klar die Absicht hat einen Nachfolger für Objective-C zu formen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    UISplitViewController mit Swift

    Der UISplitViewController ist mit dem Navigation Controller vergleichbar. Er stellt zwei Anzeigebereiche bereit, die Master- und Detailview. Der SplitViewController selbst stellst jedoch keine Inhalte dar. Er ist nur eine Art Container. Sichtbare Inhalte werden über verbundene Views angezeigt - die Master- und Detailviews. Eine Auswahlmaske wird bspw. als Tabelle in der Masterview angezeigt. In der Detailview werden ausführliche Informationen zum ausgewählte Eintrag dargestellt. So könnte in der Masterview eine Liste mit Rezepten existieren. Wählst Du eines aus, werden Dir Zutaten und Hinweise zur Zubereitung in der Detailview angezeigt.

    Die Technologie ist seit iOS 3.2 vorhanden. Bisher stand sie allerdings nur auf dem iPad zur Verfügung. Seit iOS8 ist die UISplitView, auch dank der neuen SizeClasses, auf jedem iOS-Gerät verwendbar. Das Besondere: iOS kümmert sich selbstständig um die sinnvollste Darstellung. Auf einem iPad im Querformat, also den horizontalen und vertikalen SizeClasses “regular”, wird die Masterview als ständig präsente Seitenleiste angezeigt. Hochkant im Portraitmodus wird sie auch hier ausgeblendet, kann aber jederzeit eingeblendet werden. Auf den kleineren Geräten, wie früheren iPhones, wird die MasterView-Ebene aus Platzgründen ebenfalls nur auf Wunsch angezeigt.

    In diesem Video zeige ich Dir die grundlegende Verwendung. Im ersten Schritt bereiten wir einen MasterViewController vor. In dem werden Farben angezeigt. Wählt der Benutzer einen Eintrag, ändern wir im zweiten Schritt die Hintergrundfarbe der Detailview entsprechend ab. Du lernst also erste Schritte mit dem UISplitViewController zu gehen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    TouchID unter iOS mit Swift nutzen

    Mit dem Begriff TouchID wird im iOS- und Apple-Universum die Authentifizierung über den Fingerabdruck zusammengefasst. Der Scanner ist im Homebutton integriert. Eingebaut wird er im iPhone seit dem 5S aufwärts sowie in den neueren iPad- und iPad-Mini Modellen.

    Bei der Einführung im Rahmen von iOS7 stand TouchID zunächst nur für interne Applelösungen bereit. Seit iOS8 können Entwickler ebenfalls darauf zurückgreifen. Grund genug, dass in diesem Video mit Swift auszuprobieren.

    Um den TouchID-Sensor herum ist ein kleiner Metallring. Der erkennt die Berührung und leitet den Scan ein. Wichtig ist, dass Apple hier viel Wert auf Datenschutz und Sicherheit legt. Es werden keine Bilder vom Fingerabdruck gespeichert. Stattdessen handelt es sich um eine mathematische Darstellung. Ein guter, wenn auch ungenauer, Vergleich sind Hashwerte wie SHA oder MD5. Auch hier wird lediglich eine mathematische Darstellung berechnet. Sie kann nur per Brute-Force Angriff entschlüsselt werden.

    Zusätzliche Sicherheit bietet der Secure Enclave. Die Fingerabdruckdaten werden verschlüsselt abgelegt und nur von der Secure Enclave verwendet. Diese Einheit bestätigt, ob der erkannte Abdruck den registrierten Daten entspricht. Der Chip ist laut Apple von den restlichen Bereichen des OS abgeschirmt und kann somit gar nicht direkt angegriffen und ausgelesen werden. Die Kommunikation beschränkt sich also folglich auf Eingabedaten und Wahrheitswerte, die zurückkommen.

    Wichtig ist, dass keinerlei Daten in der iCloud oder irgendwo bei Apple gespeichert werden. Der Zugriff, die Authentifizierung und auch die Datenhaltung der biometrischen Informationen geschieht nur lokal. Zugriff ist von außen nicht möglich. Nur der Secure Enclave kann die Daten auswerten. Sie werden auch nicht in Backups erfasst und so durch die Hintertür ausgelesen.

    Spannend an TouchID ist auch die Lernfähigkeit. Nach und nach ergänzt der Sensor sein Bild vom Finger und kann immer zuverlässiger arbeiten.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    UIStackView in iOS9

    UIStackView ist eine weitere Erleichterung bei der Interface Gestaltung von Oberflächen für iOS-Apps. Ziel ist es, die Anzahl der notwendigen Autolayout Constraints zu verringern und das Interface erweiterbar zu halten.

    Unter iOS sind Autolayout-Constraints das Mittel der Wahl wenn es um die Interface Gestaltung geht. Autolayout ist die Antwort auf die Fragen, die durch die gestiegene Zahl der verschiedenen Displaygrößen und Auflösungen entstanden sind. Webseiten nutzen responsive Layouts mit CSS und JavaScript. Die Anfänge der Universal-Apps sah vor, dass zum Beispiel für iPad und iPhone getrennte Storyboards entworfen wurden. Spätestens mit iOS8 und den SizeClasses sind die Interfaces adaptiv geworden. Es war für Entwickler noch nicht so einfach dynamische Interfaces zu entwerfen, die sich an die vorhandenen Ressourcen anpassen.

    Mit iOS9 hat Apple das Spiel noch weiter verbessert. Es gibt nun mit UIStackView einen Weg um View-Elemente automatisch anzuordnen. Dabei können Sie horizontal oder vertikal angeordnet werden. Zwischen den Elementen kann automatisch Abstand freigehalten werden. Außerdem kann die Verteilung des zur Verfügung stehenden Platzes kontrolliert werden. Unheimlich nützlich ist zum Beispiel die gleichmäßige Aufteilung auf die einzelnen Elemente.

    Apple selbst sieht dies als bevorzugten Weg, um Interfaces zu gestalten. Und dazu gibt es auch allen Grund. Wie Du in diesem Video sehen wirst, ist es extrem logisch und einfach damit umzugehen. Lediglich in den Beta-Versionen von Xcode7 (UIStackView ist erst ab Xcode7 bzw. IOS9 verfügbar) gab es noch das ein oder andere Problem und ungewollte Verhalten. Die Zukunft gehört den Stackviews, wo immer dies sinnvoll ist. Zusammen mit Autolayout Constraints spielen sie ihre volle Stärke aus.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    iOS9 mit Swift2, am Beispiel von 15 Apps

    Steig in die Entwicklung mit Apples neuer Sprache Swift ein. Du lernst Swift2 kennen und steigst mit umfangreichen Apps in die Programmierung realer Apps ein. Bei jeder App werden verschiedene Technologien verwendet, miteinander verbunden und so die Entwicklung realitätsnah vermittelt. Einen direkteren Blick hinter die Kulissen der Entwicklung einer echten App geht fast nicht.

    Los geht es mit Grundlagen der Sprache im Swift Crashkurs. Anschließend lernst Du immer mehr iOS-Frameworks kennen und nutzt sie in der Praxis.

    Zu den Anwendungen gehört eine...

    • einfache App zur Berechnung des Body-Mass-Index
    • Rezeptesammlung mit UITableView
    • Bildergalerie auf Basis der UICollectionView
    • Apps zum Abruf von Synonymen von einer JSON-API
    • Einkaufsliste mit CoreData
    • Timer-App
    • ein Würfelbecher mit SpriteKit
    • App die ihre Inhalte per JSON-API aus WordPress abruft
    • Kartenanwendung, die Orte anzeigt, speichert und auffindbar macht
    • vollständige Tabata-Timer App
    • RSS-Reader App, der die Grundlage der App zu Deinem Blog sein kann
    • Soundboard Anwendung, das witzige Geräusche abspielt und eigene aufnimmt
    • LiveErgebnisse App die per PushNotification Neuigkeiten signalisiert
    • Anwendung die über In-App Einkäufe Inhalte freischaltet
    • Instagram ähnliche App, die Daten im Parse.com Backend speichert

    Alle wichtigen iOS-Frameworks werden behandelt. Außerdem lernst Du den sicheren Umgang Xcode, Playgrounds und dem Workflow bei der Entwicklung.

    Im Kurs werden auch AutoLayout, Sizeclasses und andere wichtige Themenbereiche abgedeckt. Es geht nicht nur um Faktenwissen, sondern um ein Gesamtverständnis der Materie.

    Der Kurs umfasst mittlerweile über 27 Stunden Videomaterial, inkl. einiger Bonuslektionen, Quiz und Übungsaufgaben mit Musterlösungen zu jedem Kapitel.

    Das Training ist mehr als nur eine Sammlung einzelner Tutorials. Die genutzten Technologien stellen einen gezielten Mix dar. In jeder App werden weitere Technologien eingeführt, die in der täglichen Praxis als Entwickler wichtig sind.

    Und das besondere bei einem Videotraining: Es bietet mir als Trainer die Möglichkeit Dir nicht nur das WIE zu vermitteln. Gleichzeitig kann ich, wo dies dem Verständnis hilft, das WARUM erläutern und meine Entscheidungen begründen. In einem Buch geht das nur begrenzt.

    Der Kurs - iOS9 mit Swift2, am Beispiel von 15 Apps - richtet sich an Einsteiger und Umsteiger. Erste Programmiererfahrung sind optimal. Auch erster Kontakt mit Begriffen wie Objekten, Klassen und Instanzen ist von Vorteil.

    Gleichermaßen kommen auch erfahrene Entwickler hier voll auf ihre Kosten. Ich wähle bewusst einen Mittelweg und nehme den Entwickler mit jeder App zunehmend weniger an die Hand. Es kommt also jeder auf seine Kosten.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    iOS mit Swift: NSTimer mit Swift verwenden

    Ein NSTimer kann wunderbar für eine Stoppuhr oder für einen Teatimer verwendet werden. Außerdem gibt es auch unzählige Beispiele für zeitgesteuerte Abläufe, bei denen der Benutzer nicht unmittelbar den zeitlichen Fortschritt sehen muss. Aber auch ohne Darstellung der abgelaufenen Zeit, muss diese berechnet werden. Die Lösung ist der NSTimer.

    Bei der Arbeit mit dem NSTimer gibt es zwei wesentliche Herausforderungen. Zum einen muss das Verständnis für den Timer vorhanden sein. Die Klasse selbst hilft nur dabei die verstrichene Zeit zwischen zwei Intervallen zu erfassen.

    Periodisch ruft der "scheduledTimer" einen Selektor auf. In dieser Methode, die wir in diesem Video implementieren, erfassen wir die verstrichene Zeit seit dem letzten Aufruf. Genau diese Zeit wird anschließend zur Gesamtzeit hinzuaddiert.

    Der zweite Knackpunkt ist ein Timer, der pausiert und wieder fortgesetzt werden kann. Auch diese Herausforderung meistern wir in diesem Video gemeinsam.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    Vielen Dank an Jan Brickmann für die tollen Videos.
    Wir wünschen allen viel Spaß und Erfolg beim Zuschauen und Lernen :)

    Blog: http://codingtutor.de/

 

oder registriere Dich, um zu antworten!