Résumé

Concevoir une application native iOS 6 et la publier avec succès sur l’Apple Store exige un savoir-faire en ergonomie mobile et la maîtrise de l’ensemble des contraintes spécifiques à la plate-forme iOS 6.

Cet ouvrage pour iOS 6 aborde le développement d’applications iPhone, iPad et iPod Touch dans tous ces aspects, depuis l’inscription chez Apple et l’achat de licence du SDK à la distribution sur l’AppStore… sans oublier les bonnes pratiques de conception et les design patterns d’interface.

Une référence pour réussir ses applications iPhone et iPad professionnelles sous iOS 6

De la conception de l’application – encadrée par de strictes règles d’ergonomie – jusqu’à son déploiement, cet ouvrage détaille les bonnes pratiques garantissant la qualité de vos développements sous iOS 6 : gestion de projet et architecture MVC, ergonomie mobile et design patterns d’interface. Les fondamentaux du développement iOS sont détaillés, de l’Objective-C et sa gestion spécifique de la mémoire avec l’ARC (Automatic Reference Counting) aux contrôleurs de vue, en passant par la mise en place des storyboards, des vues, des listes TableViews etc.

L’ouvrage traite en profondeur d’aspects fondamentaux tels que l’accès aux services web (JSON, XML), la gestion de fl ux audio et vidéo, la persistance avec le framework CoreData et l’utilisation du service de notifications Apple APNS. Il fournit de précieux conseils pour publier sur l’App Store et y gagner en notoriété.

Au sommaire

L’environnement de développement • Développer pour iPhone/iPad • Matériel requis • Objective-C et le SDK iOS • L’orientation objet • Programmation multithread • La bibliothèque standard Foundation • Comptage de références et ARC • Xcode • Le fichier info.plist • Storyboard • Schémas de compilation et débogage • Conception et ergonomie • Méthode de développement d’un projet iOS • Principes ergonomiques et designs patterns d’interface • Métaphores • Listes d’éléments (TableViews) • Listes groupées • Barres d’outils • Listes hiérarchiques • Ergonomie iPad avec SplitViewController • Collections d’objets • Conception de l’interface mobile • Fréquence d’utilisation • Développement de l’interface • Contrôler les écrans de l’application • Modèle MVC dans iOS • Contrôleur de vue • Transitions • Assembler les écrans de l’application • Contrôleurs-conteneurs • Navigation avec un storyboard • Onglets • Mode modal • Animer les vues • Hiérarchie et redimensionnement automatique (Auto Layout) • Listes déroulantes : les PickerViews • Délégation de contrôle • Sources de données • Liste d’éléments • TableViews • Contact et gestuelle • Détection de doigts • La classe UITouch (swipe, pan, pinch…) • Manipulation des données • Lire et enregistrer les données • Préférences utilisateur • Propriétés plist • JSON • Géolocalisation avec MapKit • Communiquer avec l’extérieur • Traitements en arrière-plan • Connexions réseau asynchrones • Persistance d’objets avec l’ORM Core Data • Manipuler les données son et vidéos • L’API de notification APNS • Images, animations et graphiques avec Core Image, Core Graphics, Core Animations et OpenGL • Publication sur l’AppStore.

À qui s’adresse cet ouvrage ?

– Aux professionnels de la conception web et mobile qui souhaitent être présents sur le marché des services portés sur iPhone et iPad ;

– À tous les particuliers et fans d’iPhone et iPad qui souhaitent concevoir, publier ou vendre une application sur l’App Store.

Biographie auteur

J.-M. Lacoste

Jean-Marc Lacoste s’est orienté vers les systèmes Unix/Linux et le C après avoir débuté dans les langages d’intelligence artificielle (Lisp, Scheme, Prolog, Ada, etc.). Consultant depuis 20 ans chez Ambre Systems, il partage son temps entre la formation en milieu professionnel et les interventions auprès des constructeurs (Digital, HP, Sun, IBM), éditeurs et leurs partenaires. À l’arrivée de la plate-forme iOS, il a repris le développement sous l’angle de la formation : la prise en main du langage Objective-C et de l’ensemble de l’environnement de développement sous Xcode pour réaliser rapidement des applications cohérentes et efficaces.

T. Sarlandie

Thomas Sarlandie est co-fondateur de Backelite, l’agence mobile leader en ergonomie et développement d’applications mobiles. Il a été l’un des pionniers du développement pour iPhone en France et a souhaité partager sa passion et cette expérience à travers ce livre.

www.editions-eyrolles.com

Programmation

iOS 6

Conception et publication

d’applications iPhone & iPad

Jean-Mar c Lacoste

Thomas Sarlandie

Avec la contribution de Grégoire Péan

ÉDITIONS EYROLLES

61, bd Saint-Germain

75240 Paris Cedex 05

www.editions-eyrolles.com

Remerciements à Grégoire Péan pour sa contribution et à Anne Bougnoux pour sa relecture.

Attention : la version originale de cet ebook est en couleur, lire ce livre numérique sur un support de lecture noir et blanc peut en réduire la pertinence et la compréhension.

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre Français d’exploitation du droit de copie, 20, rue des Grands Augustins, 75006 Paris.

© Groupe Eyrolles, 2013, ISBN : 978-2-212-13639-5

COLLECTION BLANCHE

F. DAOUST, D. HAZAËL-MASSIEUX. – Relever le défi du Web mobile.

Bonnes pratiques de conception et de développement.

N°12828, 2011, 300 pages.

E. SARRION. – jQuery Mobile.

La bibliothèque JavaScript pour le Web mobile.

N°13388, 2012, 610 pages.

J. STARK. – Applications iPhone avec HTML, CSS et JavaScript.

Conversions en natifs avec PhoneGap.

N°12745, 2010, 190 pages.

J.-M. DEFRANCE. – Ajax, jQuery et PHP.

42 ateliers pour concevoir des applications web 2.0.

N°13271, 3e édition, 2011, 482 pages.

R. GOETTER. – CSS avancées. Vers HTML 5 et CSS 3.

N°13405, 2e édition, 2012, 400 pages.

R. RIMELÉ. HTML5. Une référence pour le développeur web.

N°13638, à paraître en 2013, 644 pages.

E. DASPET, C. PIERRE DE GEYER. – PHP 5 avancé.

N°13435, 6e édition, 2012, 900 pages environ.

J. PAULI, G. PLESSIS, C. PIERRE DE GEYER. – Audit et optimisation LAMP.

N°12800, 2012, 300 pages environ.

S. JABER. – Programmation GWT 2.5.

Développer des applications HTML5/JavaScript en Java avec Google Web Toolkit.

N°13478, 2e édition, 2012, 540 pages.

C. PORTENEUVE. – Bien développer pour le Web 2.0.

Bonnes pratiques Ajax.

N°12391, 2e édition, 2008, 674 pages.

COLLECTION ACCÈS LIBRE

A. FAQUE. – Google Android 4 efficace

Utilisation avancée des smartphones Android (Samsung Galaxy, Nexus, HTC…)

N°13481, 2012, 218 pages.

T. BAILLET. – Créer son propre thème WordPress pour mobile.

N°13441, 2012, 128 pages.

A. BOUCHER. – Ergonomie web illustrée. 60 sites à la loupe.

N°12695, 2010, 302 pages (Design & Interface).

I. CANIVET. – Bien rédiger pour le Web.

Stratégie de contenu pour améliorer son référencement naturel.

N°12883, 2e édition, 2011, 552 pages.

N. CHU. – Réussir un projet de site web.

N°12742, 6e édition, 2010, 256 pages.

H. COCRIAMONT. – Réussir son premier site Joomla! 2.5.

N°13425, 2012, 160 pages.

COLLECTION DESIGN WEB

C. SCHILLINGER. – Intégration web : les bonnes pratiques.

Le guide du bon intégrateur.

N°13370, 2012, 400 pages.

K. DELOUMEAU-P...

Avant-propos

Après le succès sans précédent de l’iPhone en 2007, Apple a transformé les usages en introduisant l’iPad en 2010.

Notre façon d’utiliser les outils informatiques s’est ainsi rapidement modifiée ; les iPads sont présents dans notre vie quotidienne, au bureau comme à la maison, et remplacent progressivement les ultra-notebooks.

En permettant aux développeurs de réaliser leurs propres applications sur les appareils et en gérant le circuit de ventes, Apple a réussi en quelques années à devenir l’une des sociétés les plus prospères de la planète, et propose un nombre sans cesse croissant d’applications sur l’ensemble de ses appareils mobiles.

Apple a su réinvestir pour faire évoluer sa plate-forme de développement en cherchant continuellement à simplifier le processus de développement des applications. Ces mutations rapides sont parfois déconcertantes, mais une fois maîtrisées, elles apportent une richesse fonctionnelle passionnante pour le développeur.

Cette nouvelle édition du livre Programmation iPhone OS 3 de Thomas Sarlandie présente les nouveautés et les modifications qui...

PREMIÈRE PARTIE

Découverte de l’environnement de développement

Cette première partie constitue une introduction indispensable au développement iOS. Après un rappel des bases de l’Objective-C, elle donne un aperçu de l’environnement de développement pour créer et tester un premier exemple d’application simple.

Le chapitre 1 présente les différents programmes développeurs, l’inscription et le téléchargement des outils et documentations. Le développeur y trouvera également des explications pour créer un certificat de développement, indispensable pour tester son application sur un iPhone.

Le chapitre 2 est une introduction à l’Objective-C. Destiné à des développeurs familiers de la programmation orientée objet, il présente le langage d’une façon très pragmatique visant à vous rendre opérationnel rapidement.

Enfin, le chapitre 3 permet au développeur de faire sa première application et de la tester dans le simulateur et sur son iPhone. Les outils indispensables comme Xcode et Interface Builder sont introduits en suivant quelques exemples très simples.

1

Développer pour iPhone et iPad

Le développement d’applications iPhone, iPod touch et/ou iPad sous iOS 6 est à la portée de tous les développeurs. Seuls un Mac, un iPhone et/ou un iPad et l’inscription au programme développeur Apple sont nécessaires pour développer son application, la tester et la publier.

Ce premier chapitre couvre les prérequis matériels et les connaissances qui seront utiles au développeur, avant d’accompagner le lecteur dans l’inscription à l’un des programmes développeurs iOS et dans la création d’un certificat pour signer et distribuer des applications. Il est destiné aux développeurs, mais aussi au reste de l’équipe qui y trouvera comment s’inscrire pour accéder à la documentation, comment ajouter un appareil de test, etc.

Équipement matériel requis

Pour développer une application iPhone/iPad sous iOS, il faut disposer d’un Mac et d’un appareil de test.

Un Mac Intel pour développer

Officiellement, le développement d’applications iPhone avec le SDK Apple ne peut se faire que sur des Mac équipés d’un processeur Intel. En pratique, c’est la seule solution pour le développeur qui souhaite publier ses applications sur l’App Store.

Un iPhone, un iPod touch ou un iPad pour tester l’application

Avoir un iPhone, un iPod touch et/ou un iPad à disposition est indispensable. Les règles ergonomiques de la plate-forme et les contraintes liées à la taille de l’écran ne peuvent être comprises sans avoir l’appareil entre les mains. De plus, le simulateur possède quelques contraintes qui ne permettent pas de tout pouvoir programmer ; le système de notification, par exemple, n’est pas pris en charge par le simulateur.

Bien qu’un iPod touch puisse servir pour tester la plupart des applications, il ne permettra pas de tester votre application dans un contexte EDGE ou 3G (c’est-à-dire avec un débit très différent du Wi-Fi) et vous privera de certaines des applications auxquelles les utilisateurs sont très habitués, comme le téléphone.

CONSEIL Utilisez quotidiennement votre appareil

Pour développer des applications iOS, il est fortement recommandé de posséder un iPhone ou un iPad (ou les deux), de l’utiliser comme téléphone principal et de télécharger fréquemment des applications.

Gardez en permanence un regard curieux et critique sur les nouveautés de l’App Store, c’est votre première source d’inspiration. Il n’est pas envisageable de développer des applications pour iPhone/iPad sans être un utilisateur averti. Chaque jour, de nouvelles offres promotionnelles vous permettent de télécharger gratuitement certaines applications ou de les acheter à des tarifs vraiment très bas.

Compétences techniques utiles au développeur iOS

Le développeur d’applications iOS doit maîtriser plusieurs connaissances. Elles ne sont pour la plupart pas spécifiques au développement d’applications pour mobiles ou à l’environnement Mac et vous les...

2

L’essentiel d’Objective-C

Objective-C est le langage de programmation du SDK iOS. Sa syntaxe peut sembler déroutante au premier abord, mais les développeurs habitués aux langages de programmation orientés objet s’y habitueront très vite et ne tarderont pas à en découvrir les avantages.

Ce chapitre est une introduction rapide à Objective-C, mais amplement suffisante pour développer vos premières applications avec iOS.

APPROFONDIR Guide de programmation Objective-C

Apple fournit gratuitement en ligne un guide appelé The Objective-C 2.0 Programming Language qui est la référence du langage utilisé pour développer des applications iOS.

Ce guide explique en détail toutes les possibilités du langage et fournit de nombreuses explications et conseils. Sa lecture est très fortement recommandée.

Les origines

Objective-C est inventé au début des années 1980 par Brad Cox, créateur de la société Stepstone. Son objectif est de combiner la richesse du langage Smalltalk (un des premiers langages orientés objet) et la rapidité du C.

Ses travaux aboutissent en 1986 à la publication du livre Object-Oriented Programming, An Evolutionary Approach, le premier décrivant complètement le langage, puis à la mise sur le marché d’un compilateur Objective-C et d’un ensemble de bibliothèques.

Steve Jobs, prié de quitter Apple, fonde en 1985 la société NeXT, qui édite des logiciels et fabrique des matériels. En 1988, NeXT achète à Stepstone le droit de réaliser son propre compilateur Objective-C et ses bibliothèques.

Le système d’exploitation des ordinateurs NeXT (NextStep) est alors développé en Objective-C, puis NeXT se concentre sur les logiciels et vend NextStep comme une plate-forme de développement.

En juin 1996, Apple rachète NeXT Software et récupère toute la technologie NextStep. Cette dernière revoit le jour quelques années plus tard dans Mac OS X sous le nom Cocoa et enfin dans iOS sous le nom Cocoa Touch.

Objective-C 2.0 est une nouvelle version du langage introduite avec Mac OS X 10.5 (Leopard).

Principes fondamentaux

Comme tout langage, Objective-C pose quelques principes fondamentaux qui structurent tout le langage et ses bibliothèques de base.

Tout est objet

En Objective-C, tous les objets héritent de la classe NSObject (on retrouve ce principe en Java où tous les objets héritent de java.lang.Object).

Toutes les méthodes de l’objet NSObject sont donc accessibles dans tous les objets que vous créerez et manipulerez.

Cela signifie aussi qu’une méthode ou une classe capable de...

3

Premiers pas avec le SDK iOS

Vous venez de vous familiariser avec Objective-C dont vous maîtrisez à présent les bases. Il est temps d’appréhender concrètement le développement iOS pour un déploiement sur iPhone, iPad ou iPod touch. Ce chapitre est aussi là pour assouvir la curiosité des développeurs expérimentés qui découvrent l’environnement de développement Apple.

Nous ferons connaissance avec l’interface de Xcode et nous ferons également un tour rapide des fonctionnalités clés à bien connaître. Puis nous verrons quels sont les fichiers nécessaires pour une application minimaliste, leur rôle et le cycle de vie typique d’une application iOS. Enfin, à travers des variations autour du très classique « Hello World », nous verrons les diverses façons de créer une interface graphique et de l’afficher. Vous réutiliserez ensuite ces mêmes techniques, en les enrichissant avec de nouveaux composants. Au passage, nous apprendrons à lancer l’application sur un appareil et à la déboguer.

Après avoir lu ce chapitre, vous aurez fait le grand pas en avant dans le monde des développeurs d’applications iOS. Vous commencerez à trouver vos marques, à comprendre. Le reste du livre vous permettra d’approfondir.

À la découverte de Xcode

Entrons directement dans le vif du sujet. Lancez Xcode, fermez la fenêtre de bienvenue puis choisissez File > New Project. L’assistant de création d’un nouveau projet s’ouvre. À gauche, vous retrouvez plusieurs catégories qui permettent de créer des projets pour Mac OS X ou pour iOS. Sélectionnez Application dans iOS puis Empty Application, c’est-à-dire une nouvelle application vide dans laquelle il nous faudra tout créer.

Figure 3–1 Assistant de création d’un nouveau projet

Les modèles de projet

Xcode propose plusieurs modèles de projets (appelés templates), qui sont autant de modèles d’applications standards. Le modèle le plus simple est Empty Application, c’est-à-dire une application vide.

ESSENTIEL Fenêtre et vues

En général, les applications iOS sont composées d’une seule fenêtre (UIWindow).

À l’intérieur de cette fenêtre, l’application crée des vues (UIView) qui peuvent occuper toute la surface de l’écran, ou seulement une partie. Nous verrons comment créer des hiérarchies de vues complexes, gérer les transitions d’une vue à l’autre (avec des effets de glissement ou d’apparition) rappelez-vous simplement que vous ne devrez jamais chercher à créer d’autres fenêtres (UIWindow). La fenêtre est le support sur lequel reposeront vos vues.

Les autres modèles de projet économisent quelques minutes de travail au développeur, mais ils risquent surtout de perturber le développeur débutant qui, n’ayant pas écrit lui-même le code, peut ne plus comprendre comment l’application fonctionne. Aussi vaut-il souvent mieux s’appuyer sur le modèle Empty Application quand on démarre un projet.

Les modèles pourront servir de source d’inspiration : créer un projet modèle, regarder le code produit et reproduire dans un modèle d’application basée sur une fenêtre. Ils serviront aussi aux développeurs expérimentés qui maîtrisent déjà bien le SDK, comprennent ce que fait l’assistant et pourront l’utiliser pour des développements express (une application construite en quelques heures pour valider un concept ou relever un défi !).

Découverte d’un projet iPhone ou iPad vide

Après avoir choisi de créer un nouveau projet d’application de type Empty Application, Xcode demande :

• un nom de projet (Product Name) ;

• le nom de votre société (Company Identifier) ;

• un éventuel Class Prefix qui sera ajouté au début des noms de chacune de vos classes ;

• Device Family, les appareils pour lesquels le projet est destiné (Universal désignant un projet à la fois pour iPhone et iPad) ;

• Use Core Data si vous utilisez un fichier Core Data pour la persistance des données. Nous n’en avons pas le besoin pour cette première application ;

• Use Automatic Reference Counting, qui doit être cochée pour que les désallocations de mémoire s’effectuent automatiquement ;

• Include Unit Tests que vous ne sélectionnerez pas pour l’instant car nous ne désirons pas de tests unitaires.

Puis, le dossier dans lequel nous allons enregistrer le projet et l’éditeur de code se lancent. Donnez le nom HelloWorld au projet.

Figure 3–2 La fenêtre Xcode après la création d’un projet basé sur une fenêtre

Organisation

...

DEUXIÈME PARTIE

Conception et ergonomie

Cette deuxième partie s’adresse à toute l’équipe en charge de l’application, les développeurs, les experts métier, les créatifs (graphistes).

La plupart des équipes sont habituées au développement d’applications web ou client lourd. Le chapitre 4 présente ainsi le cycle habituel de développement d’un projet iOS, ses spécificités, les différentes phases et le rôle de chaque intervenant. Il permet de partager un cadre méthodologique qui sera adapté au contexte de l’équipe en charge du projet et à ses habitudes.

Le chapitre 5 donne les bases de l’ergonomie iPhone que toute l’équipe doit maîtriser. Les conventions iPhone, leur logique et leur utilisation au sein des applications standard sont détaillées car il est essentiel de bien les avoir comprises pour concevoir l’interface d’une nouvelle application.

C’est justement le sujet du chapitre 6 qui propose une méthode permettant de partir d’une liste de fonctionnalités pour arriver à une interface utilisateur. Nous verrons comment exploiter les éléments standard pour créer une nouvelle application et comment éviter les erreurs classiques.

4

Méthode de développement d’un projet iOS

Comme pour tout projet informatique, le succès d’un projet d’application iOS dépend fortement de la méthode mise en place pour le réaliser ; cette méthode doit être adaptée aux spécificités des appareils que sont l’iPhone, l’iPad et l’iPod touch.

Après avoir rappelé les objectifs de la méthode, nous passerons en revue les différentes étapes permettant de produire une application : de l’idée à la publication.

Qu’est-ce qu’un projet d’application réussi ?

La méthode mise en place doit avoir deux objectifs principaux :

1 satisfaire les utilisateurs de l’application ;

2 maîtriser la durée du projet (et donc le coût du développement).

Satisfaire les utilisateurs

Pour satisfaire ses futurs utilisateurs, une application iOS doit fournir un service clair et utile en situation de mobilité. L’interface doit être comprise rapidement et les fonctionnalités principales mises en avant. Enfin, l’application doit se lancer instantanément, fonctionner sans ralentissement, ne pas quitter brutalement et ne doit pas avoir d’effet de bord sur le téléphone dans son ensemble (empêcher les autres applications de fonctionner normalement, vider la batterie trop rapidement, etc.).

Cet objectif n’est pas spécifique au monde des terminaux mobiles, mais il est trop souvent négligé et, dans le cadre d’un projet iOS, il est essentiel de lui redonner toute son importance. Conception de l’interface, ergonomie, tests et optimisation seront donc des phases clés de la méthode.

Maîtriser le projet

Dans la majorité des environnements de développement (sociétés de services, équipe de développement en interne, freelance ou développeur individuel), on considère que la...

5

Principes ergonomiques et design patterns d’interface

Réfléchir à l’ergonomie d’une application, concevoir son interface en fonction du domaine fonctionnel plutôt que de subir des contraintes techniques est devenu essentiel dans la réalisation de projets informatiques.
Le succès de iOS est sans aucun doute très largement dû à son ergonomie et aux efforts faits par Apple pour offrir une plate-forme sur laquelle toutes les applications reprennent les mêmes règles ergonomiques et s’appuient sur les mêmes métaphores. C’est ce qui rend l’utilisation des appareils si homogène et agréable pour les utilisateurs.
Les développeurs (au sens large : toute l’équipe) doivent comprendre ces règles qui régissent l’utilisation d’un iPhone ou d’un iPad, comment les décliner pour créer une application originale et ce que le SDK propose pour les implémenter. Pour l’utilisateur, l’application sera alors intuitive et l’apprentissage très rapide ; pour le développeur, la réalisation sera facilitée et rendue plus sûre grâce à l’utilisation de composants existants.

Dans ce chapitre, nous nous intéresserons aux principaux design patterns d’interfaces et aux métaphores utilisées dans iOS. Nous verrons ensuite comment les combiner pour créer une interface utilisateur riche et simple à utiliser.

L’ergonomie dans l’univers de iOS

L’ergonomie de l’iPhone s’appuie sur des métaphores qui, en reprenant des concepts ou objets de la vie quotidienne, facilitent la prise en main de l’interface par les utilisateurs.

Outre ces métaphores, Apple a également conçu et utilisé des design patterns qui permettent de définir les grandes lignes de l’interface d’une application.

Les métaphores sont utilisées pour proposer à l’utilisateur une fonctionnalité ou l’interaction avec une donnée de l’application ; les design patterns fournissent des solutions pour organiser l’application, ses différents écrans et la navigation entre eux.

Une interface différente basée sur des métaphores

Dès le premier contact avec l’iPhone, l’utilisateur comprend que l’interface du terminal qu’il a entre les mains est très différente de celle des autres terminaux qu’il a pu utiliser auparavant. Après plusieurs essais, il comprend comment déverrouiller l’écran et commence à utiliser les applications. Seul ou guidé par un ami, il découvre l’interface, utilise son doigt pour faire défiler les contacts, les photos ou les pochettes d’albums, il comprend comment revenir à l’écran d’accueil, comment naviguer dans des listes, etc.

Pour faciliter la compréhension de l’interface par les utilisateurs, les...

6

Conception de l’interface graphique

Rappelons que vos applications doivent satisfaire des utilisateurs mobiles particulièrement exigeants. Dans ce chapitre, nous commencerons par étudier les contraintes qu’impose la situation de mobilité, puis nous proposerons une méthode qui permet d’organiser la conception. Pour vous aider à faire les bons choix, nous vous fournirons quelques outils.

Utilisation d’une application mobile

Le schéma classique d’utilisation d’une application mobile est très différent de celui de l’utilisation d’une application sur un ordinateur ou un site web.

Lorsqu’on conçoit une interface mobile, il faut prendre en compte ces spécificités et quitter les habitudes acquises dans d’autres domaines (applications Windows/Linux, sites web, etc.).

Temps et fréquence d’utilisation

Le temps moyen d’utilisation d’une application mobile est beaucoup plus réduit que celui d’une application sur Mac ou PC. En revanche, une application mobile est lancée plus souvent.

Prenez le temps d’étudier votre propre comportement : combien d’applications avezvous lancées aujourd’hui ? Combien de fois chacune ? Combien de temps à chaque fois ? Vous constaterez que, dans la plupart des cas, les applications sont lancées pour moins d’une minute et que les quelques applications les plus utilisées de votre iPhone peuvent être lancées plusieurs fois par jour.

L’application étant lancée très souvent, mais pour un temps plus court, il faut absolument qu’elle démarre rapidement.

BONNE PRATIQUE L’application doit se lancer rapidement

Les applications qui commencent par faire patienter l’utilisateur pendant plusieurs secondes avant...

TROISIÈME PARTIE

Le développement de l’interface

Nous verrons dans cette partie comment développer l’interface d’une application iOS. Tout d’abord, la brique principale de construction d’une application iPhone est le contrôleur de vue qui est expliqué en détail au chapitre 7.

On peut alors au chapitre 8 sur pencher sur l’assemblage des contrôleurs de vue pour construire une application complète, dont les écrans s’enchaînent de manière fluide.

Le chapitre 9 présente les vues, c’est-à-dire tous les éléments d’interface, et donne les clés pour bien comprendre comment assembler un écran à partir des composants graphiques fournis par le SDK et comment les adapter aux couleurs de votre application.

Enfin, au chapitre 10, on présentera les tables, qui sont les éléments les plus utilisés dans la plupart des applications, et qui permettent de faire des listes et toutes sortes d’écrans dans lesquels l’utilisateur navigue verticalement avec le doigt.

La navigation dans une liste avec le doigt est omniprésente dans les applications iPhone/iPad. Le chapitre 11 détaille les nombreux éléments fournis par le SDK pour faciliter l’implémentation de listes d’éléments, appelées TableView.

Enfin, au chapitre 12, on verra à quel point la détection et la gestion des actions de l’utilisateur sur l’écran – notamment les actions à plusieurs doigts (multi-touch) – est facile pour le développeur sous iOS.

7

Contrôler les écrans de l’application

On décompose facilement toute application iOS en une série d’écrans. Cette décomposition se retrouve de manière très naturelle dans le code de l’application : pour chaque écran, on implémente un contrôleur qui crée la vue, charge le modèle et ajoute un peu de logique métier.
La présence de storyboards dans le projet Xcode facilite la visualisation de l’enchaînement entre les différents écrans.
Les contrôleurs de vue sont donc les briques élémentaires de toute application iOS : chaque contrôleur gère un écran et peut être chaîné avec d’autres pour mettre en place des applications complexes.

La notion de contrôleur de vue est issue du design pattern MVC qui est fortement ancré dans UIKit. Dans ce chapitre, nous rappellerons le fonctionnement de ce design pattern et nous décrirons comment utiliser la classe UIViewController pour créer les contrôleurs d’une application.

À la fin de ce chapitre, vous aurez en main tous les éléments pour construire le contrôleur d’un écran de l’application. Dans le chapitre suivant, nous verrons comment assembler les contrôleurs pour enchaîner les écrans, puis au chapitre 9, nous verrons comment construire des vues riches et animées.

Le modèle MVC dans iOS

Le design pattern MVC est l’un des design patterns les plus connus dans le monde du développement logiciel. Il sépare clairement les données (Modèle), leur représentation graphique à l’écran (Vue) et la logique métier (Contrôleur) de l’application.

Le diagramme de séquence suivant rappelle le principe général de fonctionnement d’une application MVC.

Figure 7–1 Diagramme de séquence simplifié d’une application MVC

On retrouve dans iOS les trois éléments classiques du modèle MVC.

Le modèle : pour charger et stocker en mémoire les données de l’application

Toutes les applications manipulent des données métier, c’est-à-dire des informations qui représentent des objets ou des informations du monde réel – par exemple, un contact, un article, un produit, etc.

Avant d’exister en mémoire, ces objets sont chargés depuis une source quelconque (fichier XML, base de données, etc.) et peuvent être éventuellement réexportés ensuite.

Le modèle représente les données que votre application manipule, ainsi que les classes permettant de les créer et de les sauver. Pour implémenter le modèle, vous pouvez créer vos propres classes ou utiliser les classes génériques du framework Foundation (NSDictionary, NSArray, etc.). Pour lire et...

8

Assembler les écrans de l’application

Nous avons vu dans le chapitre précédent comment implémenter un écran de l’application. Cependant, les applications sont en très grande majorité construites à l’aide de plusieurs écrans qui s’enchaînent selon un des design patterns de navigation décrits au chapitre 5.

Dans ce chapitre, nous étudierons deux méthodes pour assembler les écrans de l’application : la première consiste à utiliser des contrôleurs conçus pour contenir vos contrôleurs de vue et la seconde se sert de méthodes de UIViewController pour afficher des contrôleurs de vue modale.

Généralités sur les contrôleurs-conteneurs

Les deux contrôleurs-conteneurs proposés sont le contrôleur de navigation et celui d’onglets. On trouve également le UISplitViewController particulier à l’iPad. Ils sont fournis par UIKit et diffèrent des contrôleurs de vue standards sur trois points très importants.

• Ils contiennent d’autres contrôleurs et leur transmettent les événements.

• Ils ne sont pas soumis à héritage dans votre application. Vous devez les utiliser tels qu’ils sont fournis et ne pas chercher à surcharger leurs méthodes.

• Ils gèrent plusieurs écrans de l’application (en s’appuyant sur vos propres contrôleurs).

CONSEIL Évitez de créer d’autres contrôleurs-conteneurs

Bien qu’il soit possible de créer vos propres contrôleurs-conteneurs, ce processus est relativement complexe. Nous n’aborderons donc pas ce sujet.

Le contrôleur de navigation

La classe UINavigationController fournit toute la logique nécessaire pour implémenter le design pattern de navigation dans des listes hiérarchiques. Elle prend en charge l’affichage de la barre de navigation en haut de l’écran (titre et boutons), les animations entre les écrans et de nombreux petits détails indispensables pour retrouver dans votre application la même fluidité que dans les applications de l’iPhone et de l’iPad.

Figure 8–1 Le contrôleur de navigation permet d’assembler les différents contrôleurs utilisés dans vos listes hiérarchiques.

Lorsque vos contrôleurs de vue sont ajoutés dans un contrôleur de navigation, ils sont automatiquement redimensionnés pour s’ajuster à la taille disponible sur l’écran (le contrôleur de navigation prend en compte la taille de la barre de navigation en haut, mais aussi celles de la barre d’onglets et de la barre de boutons qui peuvent également être présentes).

Création d’un contrôleur de navigation

Il suffit d’instancier la classe UINavigationController en lui fournissant un contrôleur qui sera le premier écran de la hiérarchie (et donc affiché immédiatement).

UINavigationController *myNavController =

[[UINavigationController alloc]

initWithRootViewController:myViewController];

Figure 8–2 Ajout d’un contrôleur de navigation comme conteneur d’un contrôleur

Spécifier le contenu de la barre de navigation

La barre de navigation est divisée horizontalement en trois parties :

• une zone à gauche dans laquelle le bouton Retour vient se placer lorsqu’il existe une vue précédente ;

• une zone centrale pour afficher le titre de la vue en cours ;

• une zone à droite qui peut servir à afficher un bouton d’action (comme le bouton + dans l’application Contact, par exemple).

Figure 8–3 Les différentes zones de la barre de navigation

Tous ces éléments sont paramétrés par l’intermédiaire d’une propriété qui est présente sur tous les contrôleurs de vue,...

9

Développer et animer les vues

Toutes les composantes graphiques proposées par UIKit pour réaliser les interfaces des applications iOS sont des vues. Certaines sont très simples (comme un champ texte), certaines réagissent aux interactions de l’utilisateur (comme un bouton) et d’autres sont extrêmement complexes (comme la vue web qui permet d’afficher des contenus HTML), mais elles descendent toutes de la classe UIView.

Dans ce chapitre, nous présenterons la classe UIView, ses propriétés et son fonctionnement. Nous expliquerons comment composer des vues complexes à partir de vues simples, les composants graphiques les plus importants et enfin nous verrons comment internationaliser les vues de votre application.

Comprendre les vues

Une vue est un objet qui dérive de la classe UIView. Elle représente une sous-partie de sa vue parente.

Coordonnées des vues

Sur iOS, les coordonnées sont toujours mesurées en points, avec une origine située en haut à gauche. L’axe X est horizontal et l’axe Y est vertical.

Ainsi, en supposant que l’iPhone est tenu verticalement :

• (0,0) représente le coin supérieur gauche ;

• (320,0) le coin supérieur droit ;

• (0,480) le coin inférieur gauche ;

• (320,480) le coin inférieur droit.

Bien entendu, les dimensions de l’écran sont 1024 et 768 pour un iPad, 320 et 568 pour un iPhone 5.

Centre et limites d’une vue

La zone occupée par une vue est définie par la position du centre de cette dernière (propriété center de type CGPoint) et ses limites (largeur et hauteur, propriété bounds de type CGRect).

UIView *view = [[UIView alloc] init] ;

view.bounds = CGRectMake(0, 0, 100, 50) ;

view.center = CGPointMake(160,100) ;

UIView *view = [[UIView alloc] init];

view.bounds = CGRectMake(0, 0, 100,50);

view.center = CGPointMake(160,100);

ATTENTION Origine des coordonnées

Le centre est toujours mesuré dans le système de coordonnées de la vue parente.

Figure 9–1 Centre, taille et position d’une vue

ATTENTION Limites de la vue

Il est possible d’exploiter l’origine du rectangle de la propriété bounds pour forcer la vue à ne dessiner qu’une partie d’elle-même. Dans la plupart des cas cependant, l’origine utilisée est (0,0) ce qui revient à définir la largeur et la hauteur.

Frame d’une vue

Les coordonnées d’une vue peuvent également être exprimées sous forme d’un rectangle (frame). Dans ce cas, on donne la position du coin supérieur gauche, puis la largeur et la hauteur de la vue.

Vous accédez au rectangle représentant la vue grâce à la propriété frame de type CGRect. Elle est accessible en lecture et en écriture (les propriétés center et bounds sont synchronisées automatiquement).

// Équivalent de l’exemple précédent.

view.frame = CGRectMake(110, 75, 100, 50);

Figure 9–2 Coordonnées en utilisant la frame plutôt que...

10

Listes déroulantes les PickerViews

Au-delà de la présentation et de l’utilisation des PickerViews, ce chapitre va revenir sur deux design patterns très importants pour structurer les échanges entre vos contrôleurs de vue et les vues : la délégation de contrôle et les sources de données. Ces deux mécanismes permettent la communication entre la vue et le contrôleur dans le modèle MVC.

Le design pattern délégation de contrôle

Nous avons présenté au chapitre 3 le design pattern délégation de contrôle et un cas d’utilisation avec le délégué de l’application.

Le schéma page suivante résume le fonctionnement d’un PickerView :

• Après avoir alloué le PickerView dans la vue, le delegate et le dataSource sont positionnés.

• Le dataSource va répondre à la méthode numberOfComponents:inPickerView : et retourner le nombre de composants à allouer.

• Chacun de ces composants va invoquer à son tour la méthode pickerView:numberOfRows :inComponent : pour renvoyer le nombre d’éléments pour chaque composant créé.

• Enfin, pour chaque ligne, la méthode pickerView:titleForRow:inComponent : permettra de remplir les éléments avec du texte.

• Le delegate déclenchera la méthode pickerView:didSelectRow:forComponent : lorsque l’utilisateur effectuera une sélection,...