In dieser ersten Stunde richten die Teilnehmer ihre Arbeitsplatzmaschine (Mac oder Windows) mit der notwendigen Arbeitsumgebung ein. Nach erfolgreichem Setup wird ein Dummyprojekt erzeugt, an dessen Beispiel die Projektstruktur deutlich wird. In einem Überblick wird die Anbindung an Github aufgezeigt und die Frage geklärt, wie die kompilierten Apps in die öffentlichen Stores kommen. Alternative Verteilung in einem Intranet wird aufgezeigt.

1. Einrichtung eines Nutzerkontos bei Appcelerator,
2. Installation des Titanium Studios
3. Installation von XCode
4. Installation der Android SDK
5. Kompatibilitätsmatrix (OS, XCode Studio, Java)
6. Einrichtung der Entwicklungsumgebung
7. Übersicht über die Verzeichnisstruktur im Projekt
8. Erste App (Hello World!)
9. Installation auf Gerräten über iTunes/AndroidDebuggingBridge)
10. Einbindung externer Versionierung, beispielsweise überGithub
11. Provisioning (iOS), Keystore (Android)
12. Inhouse-Deployment, on Air mit QR-Code

Um eine AndroidApp zu bauen, die beim Anwender bestmöglich ankommt, ist es entscheidend, dass wir die besonderen Möglichkeiten dieser Plattform benutzen. In dieser Stunde werden Konzepte, Funktionen und Komponenten der Androidwelt vorgestellt.

1. Konventionen des User-Interfaces
2. Hardware Buttons
3. Bildschirmgrößen und -auflösungen
4. Unterschiede zu iOS
5. Activities
6. Services
7. Intents

In diesem Kurs betrachten wir die Besonderheiten der iOS-Welt. Das sind Konventionen der Benutzeroberfläche, Anwendungskomponenten und Besonderheit der Einknopfbedienung des iPhones und des iPads.

1. UserInterface-Konventionen
2. Apples HumanInterface-Guidelines

Das Coden einer Titanium-Anwendung unterscheidet sich von der Programmierung einer Webseite. In diesem Kurs lernen die Teilnehmer wie sie den Code übersichtlich halten  und  die Komplexität begrenzen können. Ziel ist robuster und wiederverwendbarer Code. Als Unterstützung und Vorbereitung empfehlen wir Oliver Ochs'  Standardwerk: „ JavaScript für Enterprise-Entwickler : Professionell programmieren … “

1. Sichtbarkeit von Variablen
2. Stay DRY
3. selbstaufrufende Funktionen
4. Closures
5. commonJS-Muster
6. Callbacks-Muster
7. Event/Observer-Muster

Ein Vorteil von Titanium ist die Verwendung der besten Konzepte aus beiden Plattformwelten. Deswegen ist die Verwendung plattformspezifischen Codes unumgänglich. In diesem Kurs werden zwei Strategien mit ihten jeweiligen Vor- und Nachteilen aufgezeigt. Soll eine App für den internationalen Markt gebaut und/oder die Codelogik streng von Texten getrennt werden (eigentlich eine sehr gute Idee), wird die nötige Technik vorgestellt.

1. Ausnutzung plattformspezifischer Möglichkeiten
2. Code-Weichen
3. plattformspezifische Dateien
4. Internationalisierung

In diesem Kurs beginnen wir mit der eigentlichen Programmierung. Wir werden der Frage der grundsätzlichen Oberflächenstruktur, ihrer Positionierung und der Interaktion (Events) nachgehen.

Wir beginnen mit den beiden Topelementen Tabgruppe und Window. Danach thematisieren wir die auf Windows zu platzierenden Benutzerschnittstellenkomponenten. Oberflächen ohne Gesten ergeben wenig Sinn. Deshalb widmen wir uns im Kurs mit den Ereignissen und ihrer Behandlung. Am Ende gehen wir auf den Splashscreen und die Icons ein.

1. Applikationsstruktur (SingleWindow/Tabgruppe)
2. Layout, Positionierung, Hierarchie
3. Events
4. Icons und Splash-Screens

Apps bestehen oft aus Listen von wiederkehrenden Elementen. Titanium stellt dafür TableViews und ListViews zur Verfügung. Beide UI-Elemente haben ihre Stärken und auch Schwächen. In diesem Kurs  werden wir beide Elemente ausführlich behandeln

Im zweiten Teil werden wir uns aller Gesten und des Beschleunigungssensors annehemen. Android ist ein Mulititaskung-Betriebsystem. Deshalb sollten während der „Schlafphasen“ gewisse Events eingeschläfert werden. Ansonsten würde die Batterie leergesaugt. Wir erfahren, wie das realisiert wird.

Danach werden wir das starke Werkzeug der 2D- und 3D-Animation kennenlernen.

Am Ende des Kurses behandeln wir die UI-Komponenten, die es nur auf einer Plattform gibt. Mit ihnen können die Stärken der jeweiligen Plattform ausgespielt werden.

1. ListViews
2. TableViews
3. ScrollViews
4. ScrollableViews
5. Orientations
6. unterstützte Gesten
7. Animationen
8. Hausschriften
9. spezifische iOS-Komponenten
10. spezifische Android-Komponenten

Obwohl eine  iPadApp nicht nur eine PDF-Schleuder sein sollte, gibt es tatsächlich Anwendungsfälle, bei denen PDFs angezeigt werden. Unter Android erfolgt die Anzeige nicht als View, sondern als Intent. Wir zeigen wie PDFs aus dem Netz geholt, gecacht und angezeigt werden.

1. Standardanzeige unter iOS
2. erweiterte Anzeige unter iOS mit speziellen Modulen aus dem Marketplace
3. Anzeige von PDFs aus dem Netz unter Android

Das Alloy-Framework ermöglicht die Anwendung des MVC-Konzeptes in der Titaniumentwicklung. Die Ansicht wird in einer XML-Datei erstellt, das Styling erfolgt einer speziellen Stylesheet-Datei. Model und Controler werden in herkömmlichen Javascriptcode bearbeitet. Das ganze Alloy ist ein Präprozessor, der aus dem Alloy-Paket ein klassisches Titaniumprojekt generiert. Das heisst, die App wird dadurch nicht schneller oder bietet mehr Feature –die Struktur wird nur klarer und eine Teamworking wird vereinfacht.

Der Kurs gibt eine Einführung in diese Technik.

1. Konzept des MVC-Frameworks
2. Alloy Models
3. Alloy Views
4. Alloy Controllers
5. Best Practice („Das gute Alloy“)

Sofern die mobile App nicht nur Produkte präsentiert, nimmt sie Daten vom Nutzer entgegen. Diese Daten müssen sinnvollerweise persistiert werden. Das heisst sie sind auch bei Wiederstatt der App, anderen Apps des Gerätes oder auch anderen Nutzern der App auf anderen Geräten verfügbar. Zur Lösung dieses Problems werden verschiedene Techniken vorgestellt.

1. Auswahl der Persistenzstrategie
2. leichtgewichtige Speicherung in Properties
3. sichere Speicherung im Systemschlüsselbund
4. SQLite-Datenbank
5. Zugriff auf das lokale Filesystem
6. Zugriff auf geräteweite Objekte (wie Kalender, Kontakte, Photogalerie)

Die App kann über das Netzwerk mit anderen Datenquellen kommunizieren. HTTP ist dabei das Standardwerkzeug. Deswegen werden wir und ausführlich mit dem Protokoll und den darauf aufsetzenden höheren Protokollen beschäftigen. Andere Protokolle wie UDP, FTP, WebSockets werden wir auch thematisieren.

1. HTTP-Client
2. Hoch- und Runterladen von Dateien
3. Spiegelung von Datenbanken
4. SOAP, XMLRPC
5. REST
6. Spiegelung und CAching von XML/JSON-Dateien
7. OAuth (Twitter, XING, Meetup, LinkedIn, Flickr …)
8. Umgang mit SSL-Zertifikaten

1. Einbindung von Werbeanbietern
2. Webradio (SHOUTcast, icecast)
3. In-App-Purchasing
4. JIRA
5. OpenShift
6. Sharepointanbindung
7. SAP-Anbindung mit OData (Netweaver Gateway)
8. UserTracking, beispielsweise mit Google Analytics
9. Einbindung von Cloudservices (ACS, Parse.com …)
10. Einfaches Einbinden von Backend-as-a-Service Anbietern wie apiomat.com , die deutschem Datenschutzrecht genügen
11. Dropbox, Box.net
12. Einbindung sozialer Dienste (Facebook, Twitter, Meetup, XING, Pinterest, Flickr)
13. Benachrichtigungssysteme (PushNotifications)

1. Audio API
2. Video API
3. Bilder/Carousel
4. Photogalerie
5. Kamera
6. Barcode-Leser

1. Positionsbestimmung und -tracking
2. native Karten (Apple, Google und OpenStreetMap)
3. Kartenoverlays
4. Offline-Karten
5. Zugriff auf Kompass und Beschleunigungssensoren
6. NFC

Als UI-Element sollte nur in Außnahmefällen auf eine sogenannte Webview zurückgegriffen werden. In diesem Kurs vwrmitteln wir die API, zeigen wir, wie man auf den Namensraum der HTML5-Seite zugreifen kann und nennen typische Anwendungsfälle.

1. API der UI-Komponente
2. Kommunikation mit der Webview
3. Anwendungsfälle

In vielen Fällen sind die bereitgestellten API-Funktionen ausreichend. Darüberhinaus können sogenannte (native) Module eingebunden werden. Sie erweitern die mobilen Apps um weitere plattformabhängige Funktionen. Beispiele dafür sind QR-Code-Reader, Unzipper oder Netwerkclients für Websockets oder UDP. Für diese Module gibt es drei Quellen: der Marketplace, Github und die Eigenentwicklung.

1. Module installieren und einbinden
2. Benutzung von Modulen aus dem Marketplace
3. Benutzung von Modulen aus dem Github
4. Erstellung von eigenen Module

Als Ausblick werden erste Schritte  zur nächsten Generation von Titanium ( Hyperloop ) genommen.