programmation ios 6 - fnac-static.com...après le succès sans précédent de l’iphone en 2007,...

Programmation

Conception et publication d’applications iPhone & iPad

Sur le site www.editions-eyrolles.com/TolP/– Dialoguez avec l’auteur– Consulter les mises à jours et compléments

J e a n - M a r c L a c o s t e

T h o m a s S a r l a n d i e

iOS 6

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

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

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

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

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

Cette nouvelle édition du livre Programmation iPhone OS 3 de Thomas Sarlandieprésente les nouveautés et les modifications qui ont été apportées jusqu’à la versiond’iOS 6.

Avant-propos

Prog_iOS6.book Page V Thursday, December 13, 2012 4:19 PM

Programmation iOS 6VI

À qui s’adresse ce livre ?Ce livre est destiné à tous ceux qui participent à un projet iOS, aussi bien sur iPhoneque sur iPad.

Les développeurs y trouveront une introduction à Objective-C (le langage utilisé parApple pour développer sous iOS), le SDK fourni par Apple, les outils comme Xcodeet Instruments et la présentation des principaux concepts utilisés pour développer desapplications.

Les experts métier, les consultants marketing et les équipes créatives y trouveront uneprésentation des principes ergonomiques fondamentaux de la plate-forme, une pro-position de méthode pour concevoir une ergonomie mobile et des conseils pour pré-parer la publication et le lancement de l’application.

Structure de l’ouvrageCe livre est construit en cinq parties conçues pour être lues dans l’ordre par un déve-loppeur expérimenté découvrant la plate-forme iOS et le monde Apple. Les parties 2et 5 sont destinées à l’ensemble de l’équipe du projet et ont été écrites dans un lan-gage moins technique.

Première partie : la découverte de l’environnement de développement

Le chapitre 1 est destiné à toute personne intéressée par le développement iOS. Ilprésente les différents programmes d’inscription proposés par Apple, l’inscription etle téléchargement des outils de développement et de la documentation. Le déve-loppeur y trouvera également des explications pour créer un certificat de développe-ment, indispensable pour tester ses applications sur un appareil.

Le chapitre 2 est une introduction à Objective-C. Destiné à des développeurs fami-liers avec la programmation objet, il présente le langage utilisé par Apple de façontrès pragmatique et destinée à vous rendre opérationnel rapidement.

Le chapitre 3 enfin, permet au développeur de de faire sa première application et dela tester dans le simulateur et sur son appareil. Les outils indispensables commeXcode et l’usage de la documentation sont introduits à l’aide d’exemples très simples.

Prog_iOS6.book Page VI Thursday, December 13, 2012 4:19 PM

Avant-propos VII

Deuxième partie : la conception et l’ergonomieLa deuxième partie du livre s’adresse à toute l’équipe en charge de l’application, lesdéveloppeurs, les experts métiers, les créatifs (graphistes).

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

Le chapitre 5 présente les bases de l’ergonomie iOS que toute l’équipe en charge dudéveloppement doit maîtriser. Les conventions iOS , leur logique et leur utilisationau sein des applications standard sont détaillées car il est essentiel de bien les avoircomprises pour concevoir l’interface d’une nouvelle application.

C’est justement le sujet du chapitre 6 qui propose une méthode permettant de partird’une liste de fonctionnalités pour arriver à une interface utilisateur. Nous verronscomment exploiter les éléments standards pour créer une nouvelle application etcomment éviter les erreurs classiques.

Troisième partie : le développement de l’interfaceLa troisième partie est consacrée au développement de l’interface de l’application.

L’élément principal constituant une application iOS est le contrôleur de vue qui estdécrit en détail au chapitre 7.

L’assemblage des contrôleurs de vue pour construire une application complète, dontles écrans s’enchaînent de manière fluide est détaillé dans le chapitre 8.

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

Le chapitre 10, par le biais des PickerViews permet de parcourir les mécanismes dedélégations qui sont présents au sein de nombreux objets en Objective-C.

La navigation dans une liste avec le doigt est omniprésente dans les applicationsiPhone/iPad. Le chapitre 11 détaille les nombreux éléments fournis par le SDK pourfaciliter 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 del’utilisateur sur l’écran – notamment les actions à plusieurs doigts (multi-touch) – estfacile pour le développeur sous iOS.

Prog_iOS6.book Page VII Thursday, December 13, 2012 4:19 PM

Programmation iOS 6VIII

Quatrième partie : la manipulation des données et la communication

Cette partie présente les différentes techniques pouvant être utilisées pour enregistrer desdonnées, ainsi que pour permettre à votre application de communiquer avec l’extérieur.

La sérialisation des classes de base (listes et dictionnaires) en XML et JSON est pré-sentée au chapitre 13, ainsi que l’utilisation du mécanisme de préférences utilisateuret les techniques de lecture d’un flux XML quelconque.

Le chapitre 14 présente le framework MapKit, qui regroupe un ensemble de classesutilisant les coordonnées de géolocalisation et manipulant des cartes. Le systèmes’appuie sur une cartographie développée conjointement par Apple et TomTom.

Le chapitre 15 montre comment combiner les techniques de stockage avec desappels réseau, et en particulier faire en sorte que l’application reste réactive mêmequand des appels réseau durent plusieurs secondes.

Le framework CoreData est présenté dans le chapitre 16. C’est une architecture com-plète de mapping objet-relationnel pour iOS et incontestablement le moyen le plus effi-cace d’enregistrer et de parcourir des volumes importants de données métiers.

L’utilisation de contenus multimédias est couverte au chapitre 17 : lecture de sons, utilisa-tion de la bibliothèque iPod de l’utilisateur, de la caméra ou encore de lectures de vidéos.

Le chapitre 18 présente le système de notifications permettant de rester en contactavec l’utilisateur, même lorsque l’application est fermée. La mise en place des notifi-cations est présentée de manière détaillée, avec des exemples en PHP pour la partieserveur qui pourront facilement être adaptés dans n’importe quel langage.

Le chapitre 19 présente les frameworks fournis par Apple, permettant de manipulerles images, de produire des graphiques et d’animer les éléments présents à l’écran.

Cette partie se termine par un chapitre 20, sur les fonctions graphiques de l’environ-nement iOS. On dispose d’un nombre impressionnant de filtres d’images et d’anima-tions faciles à mettre en place. L’API standard OpenGL ES permet de contrôlerdavantage le coprocesseur graphique.

Cinquième partie : la publication des applicationsLa dernière partie de ce livre, en un chapitre, est consacrée à la publication de vos appli-cations. Cette partie est destinée à toute l’équipe du projet qui y trouvera la liste de tousles éléments à préparer avant de pouvoir soumettre l’application à Apple, des conseilspour favoriser les chances que l’application soit validée du premier coup, et quelquesoutils utiles pour suivre le succès de votre application et préparer la prochaine version.

Prog_iOS6.book Page VIII Thursday, December 13, 2012 4:19 PM

Avant-propos IX

Les auteursThomas Sarlandie a co-fondé l’une des premières agences mobile en France. Il a étél’un des pionniers du développement iPhone et iPad dans l’hexagone et a réalisé avecson équipe des dizaines d’applications iPhone dont lemonde.fr. Grâce à l’expérience etl’aventure qu’il a vécu avec Backelite durant plusieurs années, il a pu développer cettesociété florissante en lui fournissant toutes ses compétences et sa vision de ce quel’environnement apporté par Apple offrait. Il a apporté son dynamisme et sa créativitéà l’ensemble des projets et a su conduire Backelite vers une notoriété reconnue de tous.

Jean-Marc Lacoste est depuis 20 ans consultant en informatique chez Ambre Sys-tems. Ayant commencé dans les langages d’intelligence artificielle (Lisp, Scheme,Prolog, Ada, etc.), il s’est ensuite orienté vers les systèmes Unix/Linux et le C. Parta-geant son temps entre la formation en milieu professionnel et les interventions à tra-vers les constructeurs, éditeurs et leurs partenaires, il a notamment travaillé auprès deconstructeurs comme Digital, HP, Sun, IBM ; Oracle pour du déploiement et dutuning notamment. Avec l’apparition des smartphones et notamment de la plate-forme iOS, il a repris le développement sous l’angle de la formation la prise en maindu langage Objective-C et de l’ensemble de l’environnement de développement sousXcode pour réaliser rapidement des applications cohérentes et efficaces.

RemerciementsTout bon avant-propos se doit de citer ceux qui ont contribué à l’élaboration du livrequ’il précède.

D’abord, merci à nos familles qui nous ont aidé à garder le cap pendant l’écriture etl’élaboration des exercices, parfois jusqu’à très tard dans la nuit.

Nous tenons aussi à remercier :

• Muriel des éditions Eyrolles, et les différents correcteurs et maquettistes qui ont sunous aider à finaliser ce livre, notamment Sophie, Géraldine et Laurène.

• Les différents centres de formations qui nous ont permis d’organiser leurs pro-grammes de formation et qui connaissent un franc succès.

• Et bien sûr tous ceux qui ont contribué à la première version de ce livre.

Thomas tient à remercier l’ensemble des équipes de Backelite avec qui il a tellementappris, les lecteurs de la première édition qui ont envoyé de nombreux retours, et sur-tout Jean-Marc, qui a repris avec courage et succès le flambeau pour cette nouvelleédition.

Prog_iOS6.book Page IX Thursday, December 13, 2012 4:19 PM

Table des matières

Avant-propos ................................................................................. V

PREMIÈRE PARTIE

Découverte de l’environnement de développement ..1

CHAPITRE 1Développer pour iPhone et iPad .................................................. 3

Équipement matériel requis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Un Mac Intel pour développer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Un iPhone, un iPod touch ou un iPad pour tester l’application . . . . . . . . . . . . . 4

Compétences techniques utiles au développeur iOS . . . . . . . . . . . . . . . . . . . . . . . 4La programmation orientée objet, au cœur du SDK iOS . . . . . . . . . . . . . . . . . . 4L’Objective-C : un langage comme un autre . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Programmation multithread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Développement d’un « client lourd » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Concevoir des applications universelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7L’adhésion au programme développeur d’Apple . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Développeur iOS enregistré : un accès bon marché à l’environnement de développement et à la documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Le programme Developer pour tester et publier vos applications . . . . . . . . . . . . 8

Les deux modes d’adhésion au programme iOS Developer . . . . . . . . . . . . . . . . . 8Le processus d’adhésion au programme iOS Developer . . . . . . . . . . . . . . . . . . . . 8

Le programme Entreprise pour des applications internes . . . . . . . . . . . . . . . . . . 9Le programme universitaire pour l’enseignement . . . . . . . . . . . . . . . . . . . . . . . 10

Les sites web Apple pour le développeur iPhone . . . . . . . . . . . . . . . . . . . . . . . . . 10Le centre de développement iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Le portail du programme iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11iTunes Connect, pour la publication des applications . . . . . . . . . . . . . . . . . . . 11

Présentation du SDK iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12La documentation Apple, une aide à ne pas négliger . . . . . . . . . . . . . . . . . . . . 13

Les guides pour le développeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Prog_iOS6.book Page XI Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XII

Les exemples de code : des projets Apple comme modèles . . . . . . . . . . . . . . . . . . . 14La documentation de référence exhaustive. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Distribution d’une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Préparation à la diffusion d’une application en test (mode Ad Hoc) . . . . . . . . . 15Mode de distribution via l’App Store pour une diffusion large . . . . . . . . . . . . . 23

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

CHAPITRE 2L’essentiel d’Objective-C............................................................. 25

Les origines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Principes fondamentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Tout est objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Envoi de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

La syntaxe Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Envoyer des messages à un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Le type id et la valeur nil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Déclaration d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Les variables d’instance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Les différents types de méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Faire référence à l’objet courant et à son père . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Initialisation d’une instance d’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Les protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Déclaration d’un protocole. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32Implémenter un protocole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32Déclarer une propriété. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Implémenter les accesseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Attributs des propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

La notation point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34Les sélecteurs : des pointeurs sur fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35Synchronisation de threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

La bibliothèque standard : le framework Foundation . . . . . . . . . . . . . . . . . . . . . 36Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Parcourir rapidement une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Le mécanisme de comptage de références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Vie et mort des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Création d’un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Libération de la mémoire d’un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Prog_iOS6.book Page XII Thursday, December 13, 2012 4:19 PM

Table des matières XIII

Déclaration de propriétés avec ARC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

CHAPITRE 3Premiers pas avec le SDK iOS ..................................................... 43

À la découverte de Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Les modèles de projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44Découverte d’un projet iPhone ou iPad vide . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Organisation sous Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46Fichiers produits lors de la création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Comprendre le code créé par Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48Rôle du fichier Info.plist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Édition du fichier Info.plist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49Nom de l’application et choix de l’icône . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50Personnalisation de l’écran de démarrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Rôle du délégué de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52applicationDidFinishLaunching: – Votre application a fini de se lancer . . . . . 52applicationWillTerminate: – Votre application va se terminer. . . . . . . . . . . . . 53applicationDidReceiveMemoryWarning: – Votre application doit libérer de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53applicationWillResignActive: – Votre application passe en arrière-plan . . . . . 54

Construction de l’interface avec un storyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Déclaration du lien entre l’application et son délégué . . . . . . . . . . . . . . . . . . . 57

Hommage à MM. Kernighan et Ritchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57Utilisation de la console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Création d’une nouvelle vue avec les storyboards . . . . . . . . . . . . . . . . . . . . . . . . 58Ajouter une nouvelle vue au projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

Création d’une nouvelle vue en code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62Créer une vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65Créer un label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66Créer un bouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66Assembler la vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Lancer l’application sur votre appareil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67Définir les paramètres de signature de l’application . . . . . . . . . . . . . . . . . . . . . 67Compiler et lancer l’application sur iPhone . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Manipulations des schémas de compilation (schemes) . . . . . . . . . . . . . . . . . . . . . 68Créer un nouveau schéma de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69Créer une macro utilisable pour le débogage . . . . . . . . . . . . . . . . . . . . . . . . . . 70Tester notre nouveau schéma de compilation . . . . . . . . . . . . . . . . . . . . . . . . . 71

Et maintenant ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Prog_iOS6.book Page XIII Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XIV

DEUXIÈME PARTIE

Conception et ergonomie ........................................... 73

CHAPITRE 4Méthode de développement d’un projet iOS............................ 75

Qu’est-ce qu’un projet d’application réussi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75Satisfaire les utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75Maîtriser le projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Les étapes du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76Identifier les fonctionnalités clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76Définition des principes ergonomiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77Storyboarding et spécifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78Intervention artistique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80Développement de l’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80Développement de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81Tests et optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82Publication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

CHAPITRE 5Principes ergonomiques et design patterns d’interface.......... 85

L’ergonomie dans l’univers de iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86Une interface différente basée sur des métaphores . . . . . . . . . . . . . . . . . . . . . . 86Les design patterns d’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87Deux bonnes raisons pour s’aligner sur l’ergonomie iOS . . . . . . . . . . . . . . . . . 87

Faciliter la prise en main de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87Accélérer les développements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Développer des applications originales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88Des applications pour consulter et manipuler des données . . . . . . . . . . . . . . . . . 88Les métaphores de l’interface iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Les listes d’éléments ou TableViews . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89Comportements communs aux listes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89Utilisation de sections dans une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90Ajout d’un index sur une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90Accessoires des éléments et indicateurs de détails. . . . . . . . . . . . . . . . . . . . . . . . . 90Le mode édition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

Les listes groupées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92Édition d’une liste groupée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Les design patterns d’interface iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Navigation dans une application utilitaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Prog_iOS6.book Page XIV Thursday, December 13, 2012 4:19 PM

Table des matières XV

Utilisation d’une barre d’outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Navigation dans des listes hiérarchiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

La barre de navigation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95La vue de contenu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96Les animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96Principes de navigation à respecter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Navigation par onglet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97Utilisation en combinaison avec d’autres design patterns d’interface. . . . . . . . . 97Personnalisation de la barre d’onglets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

Ergonomie iPad avec le SplitViewController . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99Ergonomie de style livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100Ergonomie de style « collection d’objets » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

CHAPITRE 6Conception de l’interface graphique....................................... 103

Utilisation d’une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103Temps et fréquence d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103Concentration et attention disponible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Méthode pour concevoir l’interface d’une application . . . . . . . . . . . . . . . . . . . . 105Identifier les fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105Trier les fonctionnalités par ordre d’importance . . . . . . . . . . . . . . . . . . . . . . 106

Les trois groupes de fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106De l’importance des trois groupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

Concevoir l’interface pour ses fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . 107Les fonctionnalités du premier groupe doivent être accessibles en un temps minimum 107Mise en avant des fonctionnalités du deuxième groupe . . . . . . . . . . . . . . . . . . 108Fonctionnalités du troisième groupe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

Quelques outils pour concevoir l’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Un accès unique à chaque fonctionnalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Éviter les menus et autres listes de fonctionnalités . . . . . . . . . . . . . . . . . . . . . 110Distinguer le premier lancement des suivants . . . . . . . . . . . . . . . . . . . . . . . . 110Adapter l’interface aux habitudes de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . 110

Mémoriser le dernier écran utilisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110Proposer à l’utilisateur de personnaliser la barre d’onglets . . . . . . . . . . . . . . . . 111

Paramètres de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Prog_iOS6.book Page XV Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XVI

TROISIÈME PARTIE

Le développement de l’interface ............................. 113

CHAPITRE 7Contrôler les écrans de l’application ....................................... 115

Le modèle MVC dans iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116Le modèle : pour charger et stocker en mémoire les données de l’application . 116La vue : pour représenter graphiquement le modèle et fournir l’interface graphique 117Le contrôleur : pour lier le modèle et la vue . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Le contrôleur de vue standard d’iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117Cycle de vie d’un contrôleur de vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

Contrôleur initialisé sans vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118Vue chargée et non affichée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119Vue chargée et affichée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119Avertissement de mémoire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

Utilisation des contrôleurs de vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120Création d’un nouveau contrôleur de vue . . . . . . . . . . . . . . . . . . . . . . . . . . . 120Instanciation d’un contrôleur de vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Créer un contrôleur de vue sans storyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . 121Créer un contrôleur de vue dans un storyboard . . . . . . . . . . . . . . . . . . . . . . . . 121

Établir des transitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122Réagir au chargement et au déchargement de la vue . . . . . . . . . . . . . . . . . . . 124

Utilisation de la méthode viewDidLoad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124Comment savoir si la vue est chargée ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

Réagir lorsque la vue est affichée ou masquée . . . . . . . . . . . . . . . . . . . . . . . . 125Affichage de la vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126Masquage de la vue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Gérer les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126Créer une méthode pour traiter l’événement . . . . . . . . . . . . . . . . . . . . . . . . . . 126Lier un événement à une action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

Gérer les rotations d’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128Événements associés aux rotations d’écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

CHAPITRE 8Assembler les écrans de l’application ..................................... 131

Généralités sur les contrôleurs-conteneurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131Le contrôleur de navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

Création d’un contrôleur de navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

Prog_iOS6.book Page XVI Thursday, December 13, 2012 4:19 PM

Table des matières XVII

Spécifier le contenu de la barre de navigation . . . . . . . . . . . . . . . . . . . . . . . . 133Titre du contrôleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134Boutons supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135Définir la façon dont est représenté le contrôleur quand il n’est plus affiché. . . 135Masquer la barre d’outils ou la barre d’onglets . . . . . . . . . . . . . . . . . . . . . . . . 136

Pousser des écrans dans le contrôleur de navigation . . . . . . . . . . . . . . . . . . . . 136Personnaliser la barre de navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Exemple complet de navigation avec un storyboard . . . . . . . . . . . . . . . . . . . . . . 137Exemple complet de navigation entièrement codé . . . . . . . . . . . . . . . . . . . . . . . 140Contrôleur d’onglets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

Création d’un contrôleur d’onglets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145Personnalisation du titre et de l’icône des onglets . . . . . . . . . . . . . . . . . . . . . 145Réagir aux événements de la barre d’onglets . . . . . . . . . . . . . . . . . . . . . . . . . 146

Suivre les changements de sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146Réagir à la personnalisation de la barre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Limiter la personnalisation de la barre d’onglets . . . . . . . . . . . . . . . . . . . . . . 147Exemple de projet avec contrôleurs d’onglets et storyboard . . . . . . . . . . . . . . . . 147Combiner les contrôleurs d’onglets avec des contrôleurs de navigation . . . . . . . 150Construction d’une combinaison onglets et navigation avec un storyboard . . . . 150Affichage d’un contrôleur en mode modal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Pousser une nouvelle vue modale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151Faire disparaître une vue modale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152Définir le mode de transition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

Construction d’une transition modale avec les storyboards . . . . . . . . . . . . . . . . 152Construction d’un SplitViewController avec les storyboards . . . . . . . . . . . . . . . 153Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

CHAPITRE 9Développer et animer les vues................................................. 157

Comprendre les vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157Coordonnées des vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

Centre et limites d’une vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158Frame d’une vue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Hiérarchie des vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160Positionnement des sous-vues et redimensionnement automatique des vues . . 160

Disposition automatique – Auto Layout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161Les vues élémentaires de UIKit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

Les labels pour afficher du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163Les vues d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164Les boutons pour déclencher des actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165Les zones de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

Prog_iOS6.book Page XVII Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XVIII

Les boutons segmentés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167Les commutateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168Les scrollviews . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169Alertes et feuilles d’action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170Utilisation d’un compteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Affichage de contenus web dans l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . 176Animation des vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176Internationalisation des vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Localisation des chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179Localisation du storyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

CHAPITRE 10Listes déroulantes les PickerViews .......................................... 183

Le design pattern délégation de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183Les sources de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185Utilisation d’une liste de type PickerView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185Création d’un simple PickerView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

Connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187Implémentation des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189Méthodes delegate et data source pour plusieurs objets . . . . . . . . . . . . . . . . . 189

La méthode pour le nombre de composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . 190La méthode pour le nombre d’éléments par composant . . . . . . . . . . . . . . . . . . . 190La méthode pour remplir les éléments pour chaque ligne . . . . . . . . . . . . . . . . . 191La méthode optionnelle pour la largeur des composants . . . . . . . . . . . . . . . . . . 192Méthode appelée lors de la sélection d’un élément. . . . . . . . . . . . . . . . . . . . . . . 192

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

CHAPITRE 11Listes d’éléments....................................................................... 195

Les deux types de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Les listes simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Les listes groupées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

Créer une TableView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196Fournir des données à une TableView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197Décider du nombre de sections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

Indiquer le nombre de lignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Afficher des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Définir les en-têtes et pieds de sections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

Réagir aux actions sur la liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

Prog_iOS6.book Page XVIII Thursday, December 13, 2012 4:19 PM

Table des matières XIX

Sélection d’un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Sélection à l’aide des storyboards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Édition dans une TableView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

Techniques pour afficher des cellules personnalisées . . . . . . . . . . . . . . . . . . . . . 202Composition de la cellule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203Dessiner manuellement le contenu de la cellule . . . . . . . . . . . . . . . . . . . . . . . 204Passage de données entre ViewControllers . . . . . . . . . . . . . . . . . . . . . . . . . . 204

Pour le passage avant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205Pour le passage arrière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

Un exemple complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208Création des ViewController . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208Création du storyboard et connexion avec les ViewController . . . . . . . . . . . . 209Le fichier RootViewController.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209Connecter les propriétés au storyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210Le fichier RootViewController.m . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212Méthodes associées aux boutons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212Déplacer les cellules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214Insérer ou supprimer une cellule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214Les méthodes de base d’un TableView. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Autres méthodes du RootViewController.m . . . . . . . . . . . . . . . . . . . . . . . . . . 217

Le fichier DetailViewController.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218Le fichier DetailViewController.m. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

CHAPITRE 12Contact et gestuelle .................................................................. 221

Détection de doigt(s) au contact de l’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221La classe UITouch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222Méthodes déclenchées par les événements liés aux mouvements des doigts . . 222

Cycle de vie d’un contact à l’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223Prise en charge des gestes courants (discrets et continus) . . . . . . . . . . . . . . . . 224

Taper à l’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225Faire glisser le doigt (swipe) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227Faire pivoter un objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228Déplacer (pan) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230Pression longue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232Pincer/zoomer (pinch) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233Gestes simultanés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Prog_iOS6.book Page XIX Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XX

QUATRIÈME PARTIE

La manipulation des données ................................... 237

CHAPITRE 13Lire et enregistrer des données ............................................... 239

Les préférences utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239Obtenir une instance des préférences utilisateur . . . . . . . . . . . . . . . . . . . . . . 240Enregistrer une valeur dans les préférences . . . . . . . . . . . . . . . . . . . . . . . . . . 240Lire les valeurs des préférences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240Permettre à l’utilisateur de modifier directement les préférences . . . . . . . . . . 241

Les fichiers de propriétés - plist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242Le format plist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242Lire un fichier de données plist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244Écrire un fichier de données plist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

Le format de données JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245Intégrer JSON dans vos applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246Manipuler des données XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248Création d’un parseur XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249Gérer les événements XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

Début du document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250Début d’un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250Récupérer le contenu texte des éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251Repérer la fermeture d’un élément et enregistrer son contenu. . . . . . . . . . . . . . 252

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252

CHAPITRE 14Géolocalisation avec le MapKit................................................ 253

Zone affichée à l’écran (région) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254Création d’un projet basé sur MapKit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

Ajout du framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254Ajout d’une vue de type MKMapView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255Géolocalisation de la vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256Positionnement de la région . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257Modification du style de carte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258Modification de la valeur du zoom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Positionner une annotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259Suivre le mouvement de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

Prog_iOS6.book Page XX Thursday, December 13, 2012 4:19 PM

Table des matières XXI

CHAPITRE 15Communiquer avec l’extérieur................................................. 263

Premiers appels réseau synchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264Modifier le comportement d’une requête synchrone . . . . . . . . . . . . . . . . . . . 265

Authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265Gestion des redirections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265Définir le délai d’attente d’une requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Réaliser des traitements en arrière-plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265Comprendre le thread principal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266Lancer un traitement en arrière-plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266Particularités des traitements en arrière-plan . . . . . . . . . . . . . . . . . . . . . . . . . 267

Interactions avec l’interface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267Connexions réseau asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

Préparation d’une requête asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269Établissement de la connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270Réception de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270Fin de connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

CHAPITRE 16Persistance d’objets avec Core Data........................................ 273

Introduction à l’ORM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274Du monde objet au monde relationnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274Gestion des relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274Performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274Notion de contexte ou de session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

Mise en place de l’environnement Core Data . . . . . . . . . . . . . . . . . . . . . . . . . . . 275Chargement de la description du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . 276Mise en place de l’entrepôt de stockage des données . . . . . . . . . . . . . . . . . . . 277Création du contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Description du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278Création d’un nouveau modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279Édition du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280Création des classes du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

Manipulation d’objets gérés par le contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282Création d’une nouvelle instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282Enregistrement des objets du contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282Exécution d’une requête pour obtenir des objets . . . . . . . . . . . . . . . . . . . . . . 282

Recherche d’une entité dans la base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283Recherche basée sur un prédicat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

Prog_iOS6.book Page XXI Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XXII

Définir l’ordre des objets renvoyés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283Aller plus loin avec les requêtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

Supprimer un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

CHAPITRE 17Manipuler des données multimédias ...................................... 285

Intégrer le son au cœur de vos applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285Les formats audio pris en charge par iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . 285Convertir les fichiers audio pour iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286Lancer la lecture de sons dans votre application . . . . . . . . . . . . . . . . . . . . . . . 287

Lecture de vidéos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289Formats de vidéos pris en charge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289Intégrer le lecteur vidéo dans une application . . . . . . . . . . . . . . . . . . . . . . . . 289S’abonner aux notifications pour suivre le déroulement de la lecture . . . . . . . . 291Personnaliser le lecteur vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292Aller plus loin avec les vidéos sous iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

Proposer des vidéos live . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292Ajouter des éléments par-dessus la vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

Accéder à la bibliothèque musicale de l’appareil . . . . . . . . . . . . . . . . . . . . . . . . . 293Parcourir la bibliothèque musicale de l’appareil . . . . . . . . . . . . . . . . . . . . . . . 293

Demander à l’utilisateur de choisir de la musique . . . . . . . . . . . . . . . . . . . . . . 293Interroger directement la bibliothèque iPod. . . . . . . . . . . . . . . . . . . . . . . . . . . 295

Contrôler l’iPod depuis l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295Tirer parti des photos et vidéos de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . 296

Vérifier ce que permet le matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Paramétrer l’interface de prise de vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Récupérer le média de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

CHAPITRE 18Utiliser les API de notifications ................................................ 301

Principe de fonctionnement d’APNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301Qu’est-ce qu’une notification ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302Prérequis pour l’utilisation du service de notification . . . . . . . . . . . . . . . . . . . 302Les notifications en quatre étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

Étape 1 : inscription au service de notification . . . . . . . . . . . . . . . . . . . . . . . . . . 303Étape 2 : transmettre le jeton APNS à votre serveur . . . . . . . . . . . . . . . . . . . . . 304Étape 3 : envoyer les notifications à votre application . . . . . . . . . . . . . . . . . . . . 306

Obtenir un certificat SSL pour le service APNS . . . . . . . . . . . . . . . . . . . . . . 306

Prog_iOS6.book Page XXII Thursday, December 13, 2012 4:19 PM

Table des matières XXIII

Envoyer une notification depuis le serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . 308Préparer le message de notification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308Envoi du message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

Étape 4 : recevoir les notifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310Réception des notifications quand l’application est fermée . . . . . . . . . . . . . . . 310Réception des notifications lorsque l’application est ouverte . . . . . . . . . . . . . . 310

Détecter les désinscriptions et les erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

CHAPITRE 19Images, animations et graphiques .......................................... 313

Core Image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313Exemple de filtre appliqué sur une image . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

Core Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315Un exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

Core Animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Animations simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Grouper les animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319Image animée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

OpenGL ES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321La troisième dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322Un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322Construction d’un tétraèdre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

CINQUIÈME PARTIE

La publication des applications ................................329

CHAPITRE 20Publier sur l’App Store.............................................................. 331

Préparer les éléments marketing en vue de la publication . . . . . . . . . . . . . . . . . 331Nom de société et langue principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335Le nom de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335Description de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335SKU : référence de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Catégorie de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Numéro de version de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Détenteur des copyrights . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Informations de contact . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

Prog_iOS6.book Page XXIII Thursday, December 13, 2012 4:19 PM

Programmation iOS 6XXIV

Informations de démonstration (Demo account) . . . . . . . . . . . . . . . . . . . . . . 337Contrat de licence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337Niveau de contrôle parental de l’application (Ratings) . . . . . . . . . . . . . . . . . . 337Pays de distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338Éléments graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

Icône de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338Captures d’écran de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

Date de disponibilité de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Prix de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Localisation de votre application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340

Éléments techniques et dernières vérifications . . . . . . . . . . . . . . . . . . . . . . . . . . 340Fournir l’application à Apple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340Dernières vérifications techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340

Mode de compilation et niveau de log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341Vérifier le contenu du paquet applicatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341Respect de la charte graphique Apple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341Messages d’erreurs réseau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341Conserver le fichier de symbole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

Après la soumission . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342Modification des éléments marketing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342Modification de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343En cas de rejet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343

Votre application est publiée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343Suivre les progrès de votre application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343

Statistiques de téléchargement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343Les rapports de crash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344

Quelques conseils de lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344Utilisez vos canaux existants pour communiquer sur l’application . . . . . . . . . 345Communiquez auprès des blogs et des sites spécialisés. . . . . . . . . . . . . . . . . . . . 345Utilisez le bouche-à-oreille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345Utilisez les réseaux sociaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345Préparez une vidéo de démonstration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346N’oubliez pas l’autopromotion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346

Index........................................................................................... 347

Prog_iOS6.book Page XXIV Thursday, December 13, 2012 4:19 PM

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 dedé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 letéléchargement des outils et documentations. Le développeur y trouvera égalementdes explications pour créer un certificat de développement, indispensable pourtester son application sur un iPhone.

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

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

Prog_iOS6.book Page 1 Thursday, December 13, 2012 4:19 PM

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

Équipement matériel requisPour développer une application iPhone/iPad sous iOS, il faut disposer d’un Mac etd’un appareil de test.

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

1Développer pour iPhone et iPad

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


Découverte de l’environnement de développementPREMIÈRE PARTIE

4

Un iPhone, un iPod touch ou un iPad pour tester l’applicationAvoir un iPhone, un iPod touch et/ou un iPad à disposition est indispensable. Lesrègles ergonomiques de la plate-forme et les contraintes liées à la taille de l’écran nepeuvent être comprises sans avoir l’appareil entre les mains. De plus, le simulateurpossède quelques contraintes qui ne permettent pas de tout pouvoir programmer ; lesystè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 per-mettra pas de tester votre application dans un contexte EDGE ou 3G (c’est-à-direavec un débit très différent du Wi-Fi) et vous privera de certaines des applicationsauxquelles les utilisateurs sont très habitués, comme le téléphone.

Compétences techniques utiles au développeur iOSLe développeur d’applications iOS doit maîtriser plusieurs connaissances. Elles nesont pour la plupart pas spécifiques au développement d’applications pour mobilesou à l’environnement Mac et vous les avez peut-être apprises au préalable.

La programmation orientée objet, au cœur du SDK iOSUne bonne maîtrise de la programmation orientée objet est un prérequis essentiel.Ce sujet ne sera pas repris dans ce livre.

L’héritage, la composition et les design patterns classiques doivent être maîtrisés, carils sont utilisés de manière intensive dans tout le SDK iOS.

CONSEIL Utilisez quotidiennement votre appareil

Pour développer des applications iOS, il est fortement recommandé de posséder un iPhone ou un iPad (oules 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 pre-mière source d’inspiration. Il n’est pas envisageable de développer des applications pour iPhone/iPadsans ê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.

R H. Bersini, La programmation orientée objet, Eyrolles, 5e édition, 2011.


Développer pour iPhone et iPadCHAPITRE 1

5

iPod

to

uch

4ed

iPho

ne 3

iPho

ne

3GS

iPho

ne 4

iPho

ne 4

SIp

hone

5iP

adiP

ad2

Nou

vel

iPad

iPad

4Ip

ad M

ini

CPU

(MHz

)10

0041

260

010

00Du

al

100

0A5

Dual

1

300

A610

00Du

al 1

000

Dual

100

0(4

xGPU

) A5

X

Dual

140

0(4

xGPU

) A6

X

Dual

1

000

A5

RAM

(Mo)

256

128

256

512

1024

256

512

1024

512

Réso

lu-

tion(

px)

640

×96

032

0×

480

640

×96

064

0×

113

676

8×

102

41

536

×2

048

768

×1

024

Diag

onal

e3,

5“3,

5“4"

9,7“

7,9"

Capa

cité

(Go)

8/32

/64

8/16

16/3

216

/32

16/3

2/64

16/3

2/64

Réso

lutio

n de

la ca

mér

a (M

px)

5/3(

avan

t)2

35/

0,3

(ava

nt)

8/0,

3 (a

vant

)8/

1.2

N/A

1/0,

3 (a

vant

)5/

0,3

(ava

nt)

5/1,

2 (a

vant

)

Vidé

oOu

iN

/AO

ui (V

GA)

Oui (

720

p)O

ui (1

080

p)N/

AO

ui (V

GA)

Oui

(720

p)O

ui

(108

0p)

Auto

nom

ie

en c

omm

uni-

catio

n

N/A

5h

6h

8h

N/A

E/3G

/W/LT

EW

E/3G

/WE/

G/W

/LTE

E/3G

/WE/

3G/W

/LTE

Rése

au M

axN/

A3,

6 M

bp/s

7,2

Mbp

/s42

,2M

bp/s

7,2

Mbp

/s54

Mbp

/s

Blue

toot

h2.

12.

02.

14.

02.

14.

0

Open

GL

ES2.

01.

12.

02.

0

Batte

rie90

0 m

Ah1

150

mAh

121

9 m

Ah1

420

mAh

142

0 m

Ah1

440

mAh

675

0 m

Ah6

930

mAh

1156

0 m

Ah11

560

mAh

449

0 m

Ah

Conn

ecte

ur30

broc

hes

Ligh

tnin

g30

broc

hes

Ligh

tnin

g

Coqu

eM

étal

lique

N/B

Pla

stiq

ueN/

B M

étal

lique

N/B

Alum

iniu

mM

étal

lique

N/B

Mét

alliq

ueN

/B

Alum

iniu

m

Dim

ensio

ns

(mm

)11

1×

59

×7

115

×62

×12

115

×58

×9

123

×58

×

7,6

243

×19

0×

1324

1×

186

×8,

824

1×

186

×9,

420

0×

135

×7,

2

Poid

s (g)

101

g13

3g

135

g13

7g

140

g11

2g

680

g/

730

g60

1g

/ 61

3g

652

g/ 6

62g

308

g/

312

g

Gyr

osco

peOu

iO

uiO

uiO

uiO

uiO

uiOu

iO

ui



6

L’Objective-C : un langage comme un autreL’Objective-C est le langage imposé pour le développement d’applications iOS. Celangage, bien qu’il provienne d’une évolution du langage C, est une nouveauté pourla plupart des développeurs arrivant sur la plate-forme iPhone/iPad et sa syntaxepeut sembler peu naturelle au premier contact.

Programmation multithreadToutes les applications iOS utiliseront plusieurs fils d’exécution ou threads. C’estgrâce à eux, par exemple, que des contenus pourront être chargés en arrière-planalors que l’interface reste réactive.

Le fait que plusieurs morceaux de code puissent accéder simultanément à la mémoirepeut entraîner de subtils bogues, difficiles à reproduire. Le développeur doit doncbien visualiser l’exécution de l’application et comprendre par quels threads chaquemorceau de code pourra être exécuté.

Développement d’un « client lourd »On parle de client lourd par opposition au client léger, qui n’embarque pas la logiquemétier de l’application. Dans une application web, le navigateur est un client légerqui ne prend en charge que l’interface, tandis que la logique métier est exécutée dansun environnement totalement distinct : sur le serveur.

Une application iPhone/iPad est un client lourd qui embarque à la fois la logiqued’affichage et la logique métier. La réunion des deux offre au développeur une maî-trise beaucoup plus grande de l’ergonomie, mais qui se paie par une augmentation dela complexité de l’application.

VOUS VENEZ D’AUTRES LANGAGES Pour les développeurs Java, PHP et C#

Le développeur Java, C# ou PHP objet devrait retrouver rapidement ses marques. Le chapitre suivant,« L’essentiel d’Objective-C », présente, en partant de Java, les éléments essentiels d’Objective-C et del’API standard : manipulation de chaînes, dates, dictionnaires, etc.

VOUS VENEZ D’AUTRES LANGAGES Synchronisation de threads

Les techniques de synchronisation entre threads en Objective-C ne sont pas différentes de celles desautres langages et le développeur ayant déjà une expérience de cette problématique ne sera pas surpris.Pour les autres, le chapitre 2 en présente les notions élémentaires, la documentation Apple reprenantégalement ce sujet.



7

Il est néanmoins possible de développer des applications iPhone/iPad qui se compor-teront comme des clients légers, n’embarquant que l’équivalent d’un navigateur detype Safari et s’appuyant sur un serveur web pour toute la partie métier. Ce typed’application web, même s’il est simple à réaliser, nécessite une connexion au réseaulors de son utilisation et une réactivité plus faible, due notamment à l’utilisation duréseau téléphonique ou Wi-Fi pour véhiculer les images.

Un développeur qui a déjà rencontré ce type de problématique, en développant desclients lourds avec Java/Swing ou C# par exemple, retrouvera facilement ses mar-ques. Les autres doivent se préparer à un changement important dans la façon deconcevoir l’application et les échanges avec l’utilisateur.

Concevoir des applications universellesLe développeur iOS peut concevoir des applications dites « universelles » qui pour-ront s’exécuter aussi bien sur iPhone et iPod touch que sur iPad, tout en adaptantleur contenu en fonction de l’appareil. Le développeur ne programme qu’un seulprojet pour l’ensemble des appareils.

L’adhésion au programme développeur d’AppleL’adhésion au programme développeur d’Apple est nécessaire pour télécharger leSDK iPhone et l’installer. L’adhésion permet également d’accéder à toute la docu-mentation, aux exemples de code et aux vidéos de présentation Apple.

Il existe plusieurs modes d’adhésion en fonction du besoin : • iOS Registered Developer ;• iOS Developer Program à titre individuel ;• iOS Developer Program au titre d’une entreprise ;• iOS Developer Enterprise Program ;• iOS Developer University Program.



8

Développeur iOS enregistré : un accès bon marché à l’environnement de développement et à la documentation

C’est le mode d’adhésion le plus simple et la première étape des autres programmes.

Ce mode est gratuit et vous permettra déjà de télécharger gratuitement l’environne-ment de développement afin de développer vos applications et de les tester, mais uni-quement dans le simulateur.

Pour vous enregistrer, il suffit de vous rendre sur le site http://developer.apple.com/ et desuivre le lien adéquat. On vous demandera alors d’indiquer votre identifiant Apple(votre compte iCloud ou le compte utilisé pour acheter sur l’iTunes Store parexemple) ou d’en créer un et de répondre à quelques questions sur vos expériencesprécédentes de développement.

Le programme Developer pour tester et publier vos applicationsL’adhésion au programme standard (iPhone Developer Program) vous permettra detester vos applications sur iPhone et de les publier sur l’App Store. Elle est payante(99 $ ou 79 €).

Les deux modes d’adhésion au programme iOS DeveloperL’adhésion à ce programme peut se faire à titre individuel ou au nom d’une société.

Dans le premier cas, un seul développeur pourra utiliser ce compte pour créer desapplications, les signer et les installer sur des iPhone.

Dans le second cas, vous pourrez enregistrer plusieurs développeurs associés à cecompte (on ne paie qu’une fois pour toute l’équipe) et distribuer les droits aux mem-bres de l’équipe. C’est le mode recommandé pour toute équipe de développement.

Le processus d’adhésion au programme iOS DeveloperPour adhérer, il faut se rendre sur le site du programme développeur Apple et suivrele lien Continue :

CONSEIL Développer pour un tiers

Si vous souhaitez développer des applications pour le compte d’une autre société, vous devez demander àvotre client d’ouvrir son propre compte sur le programme développeur iOS et de vous ajouter comme déve-loppeur. C’est le seul moyen pour que l’application apparaisse avec le nom de votre client comme éditeur.

B http://developer.apple.com/programs/start/standard/



9

Les étapes de l’adhésion pour un développeur individuel sont les suivantes :1 Devenir un développeur iOS enregistré (voir paragraphe précédent).2 Demander l’adhésion au programme Developer et répondre aux questions sur le

site d’Apple.3 Attendre la confirmation par courriel d’Apple (quelques jours).4 Payer en ligne les frais d’adhésion.

Pour une adhésion au nom d’une entreprise, le processus est un peu plus compliqué : 1 Devenir un développeur iOS enregistré (voir paragraphe précédent).2 Demander l’adhésion au programme Developer et répondre aux questions sur le

site d’Apple – il faut indiquer le contact juridique de la société.3 Attendre quelques jours le courriel qu’Apple envoie au service juridique pour lui

demander de retourner par fax l’extrait Kbis de l’entreprise.4 Attendre la confirmation par courriel d’Apple (quelques jours).5 Payer en ligne les frais d’adhésion.

Le programme Entreprise pour des applications internesLe programme Entreprise (iOS Enterprise Program) autorise l’équipe de program-meurs d’une entreprise à développer des applications pour une distribution et unusage interne (In-House Distribution).

Ce programme ne permet pas de distribuer des applications sur l’App Store.

ATTENTION Ne pas confondre le programme Developer et Entreprise

L’inscription au programme Developer au nom de votre entreprise (deuxième mode d’adhésion décrit ci-dessus) se fait en suivant le lien Developer Program. Le choix entre l’inscription à titre individuel ou aunom d’une entreprise se fait plus tard dans le processus d’inscription.Ne confondez pas avec le programme Enterprise Program (299 $) qui sert, lui, à diffuser des applicationsen interne au sein d’un grand groupe, sans passer par l’App Store.

CONSEIL N’hésitez pas à contacter le service d’aide Apple aux développeurs

Dans certains cas, des demandes d’adhésion au nom d’une entreprise peuvent attendre longtemps avantd’être traitées, voire rester sans réponse.Le service Apple Developer Connection est très efficace et peut aider à connaître l’état d’une demande encours. Son numéro de téléphone est disponible sur le site Apple : B http://developer.apple.com/contact/phone.htmlPour la France, le numéro est : +33 (0) 800 90 7226.



10

Le programme universitaire pour l’enseignementCe programme gratuit permet à un enseignant de s’inscrire afin que ses étudiantspuissent développer, tester sur leurs appareils et publier sur l’App Store. Il permetégalement aux étudiants d’échanger leurs applications entre eux.

Il est disponible aux États-Unis depuis 2008 et en France depuis le début de l’année2009 pour quelques écoles et universités.

Les sites web Apple pour le développeur iPhoneL’adhésion au programme développeur iPhone vous donne accès à plusieurs sites webd’Apple.

Le centre de développement iOSLe centre de développement iOS (iOS Dev Center) regroupe toute la documentationdestinée aux développeurs.

B http://developer.apple.com/devcenter/ios/index.action/

Figure 1–1Le centre de développement pour les développeurs d’applications iOS



11

Vous y trouverez également des contenus vidéo, des exemples de code et des lienspour télécharger la dernière version du SDK.

C’est enfin le point d’accès au portail du programme iOS.

Le portail du programme iOSCe site est accessible depuis le centre de développement (lien iOS Developer ProgramPortal en haut à droite). C’est un outil web qui régit tous vos échanges avec Appleavant la soumission de l’application.

Il sert ainsi à : • déclarer les membres de l’équipe de développement ;• créer des certificats électroniques pour les développeurs ;• déclarer les appareils que vous utiliserez pour tester les applications.

Nous reviendrons un peu plus loin sur cet outil indispensable aux développeurs.

iTunes Connect, pour la publication des applicationsiTunes Connect est l’outil utilisé pour publier des contenus vers Apple. Il est utilisépar l’industrie musicale pour publier de la musique sur iTunes et vous l’utiliserez pourpublier vos applications une fois satisfait de votre travail.

Figure 1–2Le portail du programme développeur iOS



12

C’est également grâce à cet outil que vous suivrez les téléchargements de l’applica-tion et, dans le cas d’une application payante, vos revenus.

Présentation du SDK iOSLe SDK (Software Development Kit, kit de développement logiciel) est un paquet quis’installe depuis le Mac App Store. Il s’obtient en lançant l’application intitulée AppStore depuis le menu Application de votre Mac.

Il est aussi possible de télécharger le fichier xcode_4.5.dmg directement depuis lasection support de votre environnement de développement.

Une fois le téléchargement terminé, on peut installer Xcode en glissant l’applicationintitulée Xcode dans le dossier /Applications.

Figure 1–3Le portail iTunes Connect pour distribuer vos applications sur l’App Store



13

La documentation Apple, une aide à ne pas négligerLa documentation fournie par Apple est très riche et nous vous recommandons devous y référer. En voici un sommaire rapide permettant de retrouver l’informationpertinente.

Les guides pour le développeurLes guides font un tour d’horizon complet sur un sujet. Ils sont tous accessiblesdepuis le portail des développeurs (iOS Dev Center), en suivant le lien iOS ReferenceLibrary.

Le guide consacré aux règles à respecter en matière d’ergonomie

Le guide iOS Human Interface Guidelines décrit les principes ergonomiques qui fontde l’ensemble des appareils sous iOS une plate-forme uniforme dans laquelle les uti-lisateurs retrouvent facilement leurs marques.

La description des API et de la bibliothèque graphique

L’iOS Application Programming Guide présente les API les plus importantes del’iPhone, les limitations imposées aux applications et le fonctionnement de la biblio-thèque graphique UIKit.

La référence Objective-C

L’Objective-C 2.0 Programming Language décrit le langage Objective-C et les nou-veautés de sa version 2.0.

Tableau 1–1 Principaux composants installés avec le SDK

Nom du composant Description

Xcode L’outil de développement Apple permet la création de projets iOS, l’édition du code source Objective-C, la création graphique de storyboards, la compilation et le débogage des applications. Cet outil sert également à gérer les appareils et leurs certificats et à accéder à la documentation.

SDK Mac OS X 10.8 L’ensemble du SDK standard Mac fait partie des prérequis de l’installation.

iOS Simulator Ce simulateur est utile pour tester les applications directement sur l’ordina-teur.

Instruments Cet outil permet d’analyser un programme pour surveiller l’état de la mémoire, l’utilisation du réseau, de la CPU, etc.



14

Les exemples de code : des projets Apple comme modèlesDe nombreux exemples de projets sont fournis par Apple, chacun montrant com-ment utiliser une des API ou répondre à un problème classique.

Les exemples peuvent être téléchargés un par un en suivant le lien Sample Codedepuis l’iOS Dev Center.

La documentation de référence exhaustiveLa documentation la plus complète et la plus exhaustive couvre l’ensemble des APIpubliques d’iOS. Elle peut être consultée en ligne ou bien téléchargée pour être luedirectement depuis Xcode.1 Lancer Xcode.2 En haut à gauche, sélectionner Organizer, puis Documentation.3 Sélectionner à gauche les éléments de recherche désirés.

Distribution d’une applicationUne des révolutions apportées par les appareils sous iOS et le SDK est le modèle dedistribution intégré au terminal, qui contribue fortement au succès des appareils sousiOS et de leurs applications.

Figure 1–4La fenêtre Documentation de Xcode



15

Il existe deux modes de distribution des applications : le mode Ad Hoc et le mode depublication par l’App Store. Quel que soit celui retenu, la sécurité des applicationsest assurée par une signature électronique.

Préparation à la diffusion d’une application en test (mode Ad Hoc)Le mode de distribution Ad Hoc sert à diffuser une application à un ensemble finid’utilisateurs. Le développeur doit donner une liste des iPhone, iPod touch et iPadqui seront explicitement autorisés à lancer l’application : cette dernière ne pourra pasêtre installée sur d’autres appareils. La liste ne peut pas contenir plus de100 identifiants de terminaux.

Les applications distribuées ainsi ne sont pas soumises à la validation d’Apple. Ce modeest indispensable pour tester votre application sur un terminal réel et sera aussi intéressantpour diffuser une application auprès de bêta-testeurs ou à un petit cercle d’utilisateurs.

Pour distribuer des applications en mode Ad Hoc, le programmeur doit déjà être ins-crit au programme développeur standard. Le processus est décrit ici étape par étape.

Une fois l’environnement configuré pour la publication en mode Ad Hoc, l’appren-tissage du développement iOS peut réellement commencer.

Créer un certificat de développeur

La première étape du processus consiste à demander un certificat, qui sera transmis àApple et, une fois validé, permettra au développeur de signer électroniquement lesapplications.

Pour demander le certificat, lancez l’application Trousseau d’accès dans Applications >Utilitaires.

RAPPEL Signature électronique et certificat

La signature électronique d’un fichier permet d’en garantir l’origine et de s’assurer qu’il n’a pas été modifiépendant le transfert. Le certificat est la contre-signature de ce fichier par une autorité tierce de certification.Dans le cas des applications iPhone, le certificat est émis par Apple et permet à l’utilisateur de s’assurerque l’application provient bien du développeur et qu’elle n’a pas été modifiée (par un virus, par exemple)entre-temps.

ATTENTION Les places d’identifiants sont précieuses

Chaque terminal ajouté à la liste occupe une place dans les 100 identifiants mis à votre disposition.Même en supprimant des identifiants de la liste, vous ne récupérerez pas immédiatement ces places.Une fois par an, à la date anniversaire de votre compte, le compteur est réinitialisé et vous avez de nou-veau droit à 100 terminaux. Si au moment du renouvellement, il y a 25 téléphones déjà présents dans laliste, vous pourrez ajouter 75 nouveaux identifiants.



16

Dans le menu Trousseau d’accès, sélectionnez l’option Assistant de certification –Demander un certificat à une autorité de certificat. L’assistant se lance.

Sélectionnez l’option Enregistré sur disque et Me laisser indiquer les données de la bi-clé,validez. Indiquez l’endroit où enregistrer la demande de certificat.

Vérifier que la bi-clé créée est bien basée sur l’algorithme RSA avec 2 048 bits carApple exige ce niveau de sécurité.

Figure 1–5Lancement de l’assistant de certification

Figure 1–6Paramètres de la demande de certificat



17

Faire signer par Apple la demande de certificat

Comme nous l’avons vu, les certificats sont gérés via le portail du programme iOS.

Sélectionnez l’option Certificates, puis cliquez sur le bouton Add Certificate. Utilisez lechamp de téléchargement de fichier en bas de la page pour envoyer le certificat.

Une fois la demande transmise, elle est visible dans la page Certificats de l’App Storeet doit être approuvée par le responsable de l’équipe de développement. Pour cela, ilsuffit de cliquer sur le bouton Approve.

Figure 1–7 Envoi du fichier de demande de certificat

Figure 1–8 Validation d’une demande de certificat



18

Une fois la demande validée, un traitement a lieu pour créer le certificat. Après quel-ques minutes, le certificat validé est disponible. Il suffit alors de le télécharger et dedouble-cliquer dessus pour l’installer sur le poste du développeur.

Créer un identifiant d’application

Avant de pouvoir distribuer une application, vous devez créer un identifiant d’appli-cation (AppID) et l’associer à votre certificat.

L’identifiant déclaré dans le portail du programme iOS devra correspondre à l’identi-fiant d’application (que vous déclarerez dans le fichier Info.plist de votre applica-tion).

Un préfixe est calculé aléatoirement par Apple, ce qui garantit le caractère unique dechaque identifiant d’application. Si vous le souhaitez, vous pouvez tout de mêmeajouter votre propre préfixe, comme le nom de domaine de la société.

Ainsi, pour une société qui développerait deux applications, RSSReader et Blog-Reader, vous devriez créer deux identifiants d’application différents :com.acme2_0.rssreader et com.acme2_0.blogreader. Le préfixe unique aléatoire estajouté automatiquement et le développeur n’a pas besoin de s’en préoccuper.

Dans la section App IDs du Program Portal, cliquez sur le bouton New App ID etentrez le nom de l’application et son identifiant.

Figure 1–9 Téléchargement du certificat validé

ATTENTION Le certificat développeur est lié à la machine du développeur

Le certificat téléchargé depuis l’outil Program Portal ne contient pas la clé privée et ne suffit pas pour uti-liser cette clé développeur sur un autre ordinateur. Pour pouvoir exporter la clé privée et la réutiliser sur un autre ordinateur, référez-vous à la documenta-tion disponible dans l’onglet HowTo dans le Program Portal.Pour développer à plusieurs, chaque développeur doit avoir sa clé. C’est possible si vous avez créé uncompte développeur au nom d’une entreprise.



19

Définir les appareils autorisés

La définition de la liste des appareils autorisés se base sur les identifiants uniques detéléphones (UDID ou Unique Device IDentifier).

Figure 1–10 Création d’un identifiant d’application

ASTUCE Obtenir l’UDID d’un appareil sous iOS

L’UDID est un identifiant propre à chaque téléphone. Il peut être obtenu dans Organizer ou bien dans iTu-nes (sur Windows ou sur Mac).Pour voir l’UDID d’un appareil dans iTunes, il faut cliquer sur le libellé Numéro de série (attention, il fautbien cliquer sur le libellé ; pas sur le numéro de série lui-même), il est alors remplacé par l’UDID (Identi-fiant). En cliquant dessus et en appuyant sur Cmd-C on le copie dans le Presse-papiers.

Figure 1–11 Cliquez sur le libellé Numéro de série dans iTunes pour faire apparaître l’identifiant du téléphone (UDID).



20

Avec le programme standard, il est possible d’autoriser jusqu’à 100 terminaux. Au-delà, il faudra envisager une distribution avec le programme Entreprise (distributionsen interne à grande échelle) ou par l’App Store.

L’ajout des identifiants se fait dans le Program Portal qui est accessible depuis l’iOSDev Center. Dans l’onglet Devices, vous pouvez ajouter des téléphones à votrecompte.

Créer le profil d’approvisionnement

Dernière étape, le profil d’approvisionnement est un fichier qui lie un ou plusieurscertificat(s) avec un AppID et une liste d’appareils.

Il autorise les applications signées par un des développeurs (dont l’identifiant corres-pond à l’AppID) à être installées sur un des téléphones de la liste.

Par ce procédé, il est possible de créer plusieurs groupes de testeurs et de définir pré-cisément qui pourra tester les applications.

Dans le Program Portal, sélectionnez l’onglet Provisioning pour créer et téléchargerles profils d’approvisionnement.

Figure 1–12 Gestion des terminaux associés à votre compte développeur



21

Installer le profil sur des appareils

Le profil s’installe en faisant glisser le fichier téléchargé (extension.mobileprovision) sur iTunes ou Xcode. Cette opération est possible sous Mac etsous Windows.

Le menu Général > Profils de l’application Réglages sur l’iPhone vous aide à vérifierque le profil est bien installé.

Figure 1–13 Création d’un profil d'approvisionnement

Figure 1–14Vérification des profils installés dans l’iPhone



22

La fenêtre Organizer de Xcode (bouton Organizer en haut à droite de la fenêtreXcode) liste tous les profils installés sur l’ordinateur et montre ceux installés sur lesiPhones connectés.

Installer l’application sur des appareils

Pour le développeur, l’installation des applications sur un appareil sous iOS peut sefaire très simplement depuis Xcode, ce qui sera détaillé au chapitre 3 « Premiers pasavec le SDK iPhone ».

Pour les autres (client, testeur, ami, etc.), il est possible d’envoyer l’application parcourriel.

Le développeur devra tout d’abord compresser l’application (le répertoire dont lenom se termine en .app) et l’envoyer avec le fichier d’approvisionnement.

Pour le destinataire, il faut tout d’abord installer le profil d’approvisionnement en le fai-sant glisser sur l’icône iTunes (sous Mac ou sous Windows). Il faut ensuite décom-presser l’application et la faire glisser sur iTunes (sur Mac ou sous Windows). Elle seraalors automatiquement installée lors de la prochaine synchronisation de l’appareil.

Figure 1–15Vérification des profils installés via Organizer



23

Mode de distribution via l’App Store pour une diffusion largeLa distribution App Store propose votre application à l’ensemble des utilisateursd’iPhone dans le monde. Elle peut se faire gratuitement ou contre rémunération.Dans ce deuxième cas, Apple reverse au développeur environ 70 % des revenus.

Dans tous les cas, avant d’être disponible sur l’App Store, l’application sera vérifiéepar Apple qui s’assurera que :• L’application respecte les principes ergonomiques iPhone.• L’application ne plante pas (cependant, les tests Apple ne peuvent bien sûr pas

être exhaustifs et c’est avant tout à l’équipe de développement de s’assurer du bonfonctionnement de l’application).

• L’« accord » iOS SDK est respecté (qui précise par exemple que certains typesd’applications ne sont pas autorisés, que l’utilisation excessive du réseau est inter-dite, que les API privées ne doivent pas être utilisées, etc.).

Cette vérification peut prendre de quelques jours à plusieurs semaines et il est doncessentiel de s’assurer que l’application respecte parfaitement toutes les règles du SDKiOS avant de la publier.

Publication sur l’App Store

La publication sur l’App Store suit les mêmes étapes que celle en mode Ad Hoc, avecquelques spécificités :1 création d’un certificat spécifique ;2 réutilisation du AppID ;3 création d’un nouveau fichier d’approvisionnement pour la distribution (cette

fois-ci, vous n’indiquerez pas de terminaux autorisés à lancer l’application. Tousles terminaux le seront, une fois l’application publiée) ;

CONSEIL Vérifications à faire en cas de problème

Si le destinataire n’arrive pas à installer l’application, vérifiez les points suivants.1. L’UDID de l’iPhone, de l’iPad ou de l’iPod touch a bien été ajouté au compte développeur et il n’y a pas

eu d’erreur de saisie.2. Le terminal a été ajouté au fichier d’approvisionnement. 3. Le fichier d’approvisionnement a été téléchargé à nouveau et réinstallé par le développeur avant de

recompiler l’application. Éventuellement, il peut être utile d’effacer tous les fichiers d’approvisionne-ment d’iTunes (~/Library/MobileDevice/Provisioning Profiles/) puis de réajouterle fichier dans iTunes.

4. Le fichier d’approvisionnement a été correctement installé sur le terminal cible (vous pouvez le vérifierdans le menu Général – Profils de l’application Réglages).

5. L’identifiant d’application saisi dans Xcode correspond bien à celui fourni sur le site du programmedéveloppeur.


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 dedé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 letéléchargement des outils et documentations. Le développeur y trouvera égalementdes explications pour créer un certificat de développement, indispensable pourtester son application sur un iPhone.

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

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


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

Équipement matériel requisPour développer une application iPhone/iPad sous iOS, il faut disposer d’un Mac etd’un appareil de test.

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

1Développer pour iPhone et iPad

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


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

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

2L’essentiel d’Objective-C

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

APPROFONDIR Guide de programmation Objective-C

Apple fournit gratuitement en ligne un guide appelé The Objective-C 2.0 Programming Language qui estla 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 etconseils. Sa lecture est très fortement recommandée.


Nous ferons connaissance avec l’interface de Xcode et nous ferons également un tourrapide des fonctionnalités clés à bien connaître. Puis nous verrons quels sont lesfichiers nécessaires pour une application minimaliste, leur rôle et le cycle de vietypique 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 etde l’afficher. Vous réutiliserez ensuite ces mêmes techniques, en les enrichissant avecde nouveaux composants. Au passage, nous apprendrons à lancer l’application sur unappareil et à la déboguer.

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

À la découverte de XcodeEntrons directement dans le vif du sujet. Lancez Xcode, fermez la fenêtre de bien-venue puis choisissez File > New Project. L’assistant de création d’un nouveau projet

3Premiers pas avec le SDK iOS

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


DEUXIÈME PARTIE

Conception et ergonomie

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

La plupart des équipes sont habituées au développement d’applications web ouclient lourd. Le chapitre 4 présente ainsi le cycle habituel de développement d’unprojet iOS, ses spécificités, les différentes phases et le rôle de chaque intervenant. Ilpermet de partager un cadre méthodologique qui sera adapté au contexte del’é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 applica-tions standard sont détaillées car il est essentiel de bien les avoir comprises pourconcevoir l’interface d’une nouvelle application.

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


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 utilisateursPour satisfaire ses futurs utilisateurs, une application iOS doit fournir un service clairet utile en situation de mobilité. L’interface doit être comprise rapidement et lesfonctionnalités principales mises en avant. Enfin, l’application doit se lancer instan-

4Méthode de développement

d’un projet iOS

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


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

5Principes ergonomiques

et design patterns d’interface

Réfléchir à l’ergonomie d’une application, concevoir son interface en fonction du domainefonctionnel plutôt que de subir des contraintes techniques est devenu essentiel dans laréalisation de projets informatiques. Le succès de iOS est sans aucun doute très largement dû à son ergonomie et aux efforts faitspar Apple pour offrir une plate-forme sur laquelle toutes les applications reprennent lesmêmes règles ergonomiques et s’appuient sur les mêmes métaphores. C’est ce qui rendl’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égissentl’utilisation d’un iPhone ou d’un iPad, comment les décliner pour créer une applicationoriginale et ce que le SDK propose pour les implémenter. Pour l’utilisateur, l ’applicationsera alors intuitive et l ’apprentissage très rapide ; pour le développeur, la réalisation serafacilitée et rendue plus sûre grâce à l’utilisation de composants existants.


Utilisation d’une application mobileLe schéma classique d’utilisation d’une application mobile est très différent de celuide 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 etquitter les habitudes acquises dans d’autres domaines (applications Windows/Linux,sites web, etc.).

Temps et fréquence d’utilisationLe temps moyen d’utilisation d’une application mobile est beaucoup plus réduit quecelui d’une application sur Mac ou PC. En revanche, une application mobile estlancée plus souvent.

Prenez le temps d’étudier votre propre comportement : combien d’applications avez-vous lancées aujourd’hui ? Combien de fois chacune ? Combien de temps à chaquefois ? Vous constaterez que, dans la plupart des cas, les applications sont lancées pour

6Conception de l’interface graphique

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


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 con-trô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 pourconstruire 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 lesclés pour bien comprendre comment assembler un écran à partir des composants gra-phiques 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ésdans la plupart des applications, et qui permettent de faire des listes et toutes sortesd’écrans dans lesquels l’utilisateur navigue verticalement avec le doigt.

La navigation dans une liste avec le doigt est omniprésente dans les applicationsiPhone/iPad. Le chapitre 11 détaille les nombreux éléments fournis par le SDKpour 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 del’utilisateur sur l’écran – notamment les actions à plusieurs doigts (multi-touch) –est facile pour le développeur sous iOS.


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

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

7Contrôler les écrans de l’application

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


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

Généralités sur les contrôleurs-conteneursLes deux contrôleurs-conteneurs proposés sont le contrôleur de navigation et celuid’onglets. On trouve également le UISplitViewController particulier à l’iPad. Ilssont fournis par UIKit et diffèrent des contrôleurs de vue standards sur trois pointstrè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.

8Assembler 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 présenterons la classe UIView, ses propriétés et son fonction-nement. Nous expliquerons comment composer des vues complexes à partir de vuessimples, les composants graphiques les plus importants et enfin nous verrons com-ment internationaliser les vues de votre application.

Comprendre les vuesUne vue est un objet qui dérive de la classe UIView. Elle représente une sous-partie desa vue parente.

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

9Développer et animer les vues

Toutes les composantes graphiques proposées par UIKit pour réaliser les interfaces desapplications 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 sontextrêmement complexes (comme la vue web qui permet d’afficher des contenus HTML),mais elles descendent toutes de la classe UIView.


Le design pattern délégation de contrôleNous avons présenté au chapitre 3 le design pattern délégation de contrôle et un casd’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émentspour 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, permettant de traiter l’élément sélectionné.

10Listes déroulantes les PickerViews

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


Les deux types de listesComme nous l’avons vu au chapitre 5, il existe deux sortes de listes d’éléments : leslistes simples et les listes groupées. Techniquement, il y a peu de différences pour ledéveloppeur. Dans les deux cas, les données à représenter sont séparées en sections,puis en lignes.

Les listes simplesLes listes simples révèlent des données qui occupent toute la largeur de l’écran. Lessections (si elles sont utilisées) sont représentées par des barres horizontales conte-nant les titres et pieds de sections.

Les listes groupéesLes listes groupées exposent différents groupes de données qui peuvent être hétéro-gènes.

11Listes d’éléments

L’une des habitudes ergonomiques les plus ancrées chez les utilisateurs d’iPhone/iPad est lanavigation dans une liste avec le doigt. Ce type de navigation est omniprésent dans lesapplications et il est normal que le SDK fournisse un maximum d’éléments pour faciliterl’implémentation de listes d’éléments, appelées TableView (classe UITableView).


Deux mécanismes sont mis à la disposition du développeur pour obtenir des infor-mations sur les actions de l’utilisateur. Le premier indique de manière brute et con-tinue à l’application combien de doigts sont posés et leur position sur l’écran.

Un second niveau d’abstraction est proposé avec les détecteurs de gestes (gesture reco-gnizer). Ils reconnaissent très simplement les gestes habituels de l’utilisateur (pincer,glisser, taper, appui long) ou même de nouvelles gestuelles que vous voudriezinventer.

Détection de doigt(s) au contact de l’écranLa détection de la présence d’un doigt au contact de l’écran et de son mouvementjusqu’à ce qu’il quitte l’écran est gérée par quatre événements de la classe UIResponder.Cette classe abstraite est héritée par toutes les classes susceptibles de traiter desévénements : les vues, les contrôleurs de vue et le délégué de l’application.

En général, dans vos applications, vous recevez ces événements dans vos vues spécifi-ques (de nouvelle classes qui héritent de UIView) ou dans vos contrôleurs de vue.

12Contact et gestuelle

Pour le développeur sous iOS, la détection et la gestion des actions de l’utilisateur sur l’écran– notamment les actions à plusieurs doigts (multi-touch) – est incroyablement facile.


QUATRIÈME PARTIE

La manipulation des données

Cette partie présente les différentes techniques à utiliser pour lire et enregistrer des don-nées, ainsi que pour permettre à votre application de communiquer avec l’extérieur.

La sérialisation des classes de base (listes et dictionnaires) en XML ou en JSONsera présentée au chapitre 13, ainsi que l’utilisation du mécanisme des préférencesutilisateur et les techniques de lecture d’un flux XML quelconque.

Le chapitre 14 présente le framework MapKit, qui regroupe un ensemble de classesutilisant les coordonnées de géolocalisation et manipulant des cartes. Le systèmes’appuie sur une cartographie développée conjointement par Apple et TomTom.

Le chapitre 15 montre comment combiner ces techniques avec des appels réseau, eten particulier comment faire en sorte que l’application reste réactive même quanddes appels réseau prennent plusieurs secondes.

Le framework CoreData est présenté dans le chapitre 16. C’est un framework com-plet de mapping objet-relationnel pour l’iOS et incontestablement le moyen le plusefficace d’enregistrer et de parcourir des volumes importants de données métier.

L’utilisation de contenus multimédias est couverte par le chapitre 17 : lecture desons, utilisation de la bibliothèque iPod de l’utilisateur, de la caméra ou encore lec-ture de vidéos.

Le chapitre 18 présente le mécanisme des notifications qui permet de rester en con-tact avec l’utilisateur, même quand l’application est éteinte. La mise en place desnotifications est présentée, de manière détaillée, avec des exemples en PHP pour lapartie serveur qui pourront facilement être adaptés dans n’importe quel langage.


Le chapitre 19 présente les frameworks fournis par Apple, permettant de manipulerles images, de produire des graphiques et d’animer les éléments présents à l’écran.

Cette partie se termine par un chapitre 20, sur les fonctions graphiques de l’environ-nement iOS. On dispose d’un nombre impressionnant de filtres d’images et d’anima-tions faciles à mettre en place. L’API standard OpenGL ES permet de contrôlerdavantage le coprocesseur graphique.


Nous nous attacherons dans ce chapitre à décrire les mécanismes les plus efficaces etles plus utilisés dans des applications iOS.

Les préférences utilisateurCocoa met à disposition des développeurs un mécanisme qui enregistre des combi-naisons clé-valeur et les recharge très simplement. Ce mécanisme est implémenté parla classe NSUserDefaults et on parle des « préférences utilisateur » car il est très forte-ment recommandé de l’utiliser pour enregistrer les choix de l’utilisateur, l’état del’application quand il la ferme, etc.

13Lire et enregistrer des données

Comme toute application informatique, vos applications iPhone ont besoin de lire desdonnées et d’en enregistrer. Le SDK iOS met à votre disposition un ensemble de méthodes,des plus basiques (fopen, socket, etc.) aux plus évoluées (parseur XML, Core Data, etc.).

On montrera au chapitre 15 « Communiquer avec l’extérieur » comment combiner ces techniques avecdes accès à des serveurs distants.


Le MapKit permet d’effectuer les opérations suivantes de façon conviviale.1 Se déplacer et zoomer en utilisant la carte affichée à l’écran.2 Placer des punaises (appelées annotations) sur une carte.3 Localiser des éléments.4 Superposer des éléments à la carte.

Le MapKit se présente comme un framework qu’on ajoute à son projet et qui estbasé sur des cartes. Le SDK iOS fournit les interfaces présentant et manipulant cescartes.

L’élément principal du framework est la classe MKMapView qui est une sous-classe deUIView. Les cartes à l’écran sont présentées sous forme soit de cartes standards, soitde vues satellite, soit de vues hybrides où la vue satellite se superpose à la carte stan-dard. La région affichée est positionnée par l’utilisateur à l’aide des gestes habituelsou à l’aide des coordonnées GPS.

Les régions ainsi affichées se déforment légèrement, car l’échelle de présentation estdonnée en degrés d’angle suivant la projection de Mercator. On peut aussi utiliser laclasse MKMapRect qui manipule les coordonnées du rectangle affiché.

14Géolocalisation avec le MapKit

Le SDK fournit à l’utilisateur un ensemble de classes utilisant les coordonnées degéolocalisation et manipulant des cartes. Tous ces outils sont regroupés au sein d’unframework, le MapKit. À partir de la version iOS 6, le système ne s’appuie plus sur lescartes fournies par Google, mais sur une cartographie développée conjointement par Apple etTomTom. Du fait du niveau d’abstraction apporté par le Framework iOS, le code resteidentique. Seul les images satellites et la gestion des points d’intérêts est différente.


Nous verrons dans ce chapitre comment lancer des appels réseau vers des serveursdistants, récupérer et traiter la réponse, le tout sans ralentir l’interface. En termestechniques, il s’agira de connexions synchrones et asynchrones ; surtout nous parle-rons des threads et de leur gestion dans une application iOS.

15Communiquer avec l’extérieur

Les applications iOS communiquent pour la plupart avec un service web, que ce soit pourrécupérer des informations à présenter à l’utilisateur, mettre à jour un référentiel, ouproposer un envoi de données vers un service communautaire. Le très haut niveau de connectivité des applications est sans aucun doute l’un des atoutsd’iOS. Aussi réussir à combiner fluidité de l’application, rapidité d’apparition des donnéeset réactivité de l ’interface est-il un défi incontournable pour le développeur.

RAPPEL Connexions synchrones et asynchrones

On parle de requêtes synchrones quand la méthode utilisée pour faire un appel réseau est bloquante etattend d’avoir la réponse avant de repasser le contrôle à l’utilisateur. C’est généralement le mode le plussimple pour le développeur.Une requête asynchrone rend immédiatement la main au développeur et utilise des méthodes de call-back pour transmettre des informations sur le statut de la requête et les données reçues.


Dans ce chapitre, nous présenterons le principe de fonctionnement d’un frameworkORM, puis les bases de Core Data.

16Persistance d’objets avec Core Data

Core Data est un framework de mapping objet-relationnel (Object-Relational Mapping enanglais ou ORM) qui sert à stocker un graphe d’objets dans une base de données. Avant la démocratisation de ces outils, il était courant de passer un temps important danschaque application pour écrire des objets en charge de la persistance des données. Le plussouvent en appliquant le design pattern DAO (Data Access Objects), on écrivait du codequi exécutait les requêtes SQL pour charger et enregistrer des objets. Grâce aux frameworks ORM, les développeurs manipulent directement des objets métier enmémoire, les lient entre eux et sauvent l’état complet du graphe (c’est-à-dire celui des objets,mais aussi des relations entre ces derniers) sans écrire une seule ligne de code SQL.

APPROFONDIR Les frameworks ORM

Il est difficile de s’en passer une fois qu’on y a goûté : il existe de nombreux frameworks de mappingobjet-relationnel pour les langages modernes. Le plus connu est probablement Hibernate qui a conquisen quelques années le monde des développeurs Java et a fortement inspiré la norme EJB3.En PHP, Propel et Doctrine, intégrés notamment au framework Symfony, remplissent le même rôle etHibernate propose une implémentation .NET.


Nous montrerons dans ce chapitre comment lire des sons au sein de votre applica-tion, lancer la lecture de vidéos, accéder à la bibliothèque iPod de l’utilisateur et enfincomment utiliser l’appareil et sa caméra vidéo.

Intégrer le son au cœur de vos applicationsLe son apporte une dimension supplémentaire à votre application. Utilisé avec parci-monie et sous réserve que vous mettiez un grand soin à l’enregistrement et à la pré-paration de vos fichiers audio, il surprend l’utilisateur via un canal homme-machineencore sous-utilisé.

Les formats audio pris en charge par iOSiOS est capable de lire et de décoder différents formats audio compressés ou non. Letableau ci-après résume les principaux formats reconnus par iOS.

17Manipuler des données multimédias

L’iPhone, l ’iPad et l ’iPod touch sont plébiscités notamment pour leurs qualités deformidables plates-formes multimédia. Leurs utilisateurs ont l’habitude d’écouter de lamusique, de prendre des photos et de regarder des vidéos.


Dans ce chapitre, nous présenterons le principe de fonctionnement du service denotification. Nous montrerons comment l’utiliser au sein d’une application iOS etcomment envoyer des notifications à l’aide du langage PHP pour la partie serveur.

Principe de fonctionnement d’APNSLe service de notification d’Apple repose sur une connexion permanente entre lesserveurs Apple et l’ensemble des appareils en circulation. Cette connexion n’estactive que si l’utilisateur n’a pas désactivé les notifications dans les réglages et s’il dis-pose d’une connexion de données.

18Utiliser les API de notifications

Le service de notification poussée d’Apple (Apple Push Notification Service ou APNS pourles intimes) vous permet de garder le contact avec vos utilisateurs, même quand votreapplication n’est pas lancée. Il laisse envisager de nouveaux types d’applications : messagerieinstantanée, systèmes d’alertes (flash info, un but est marqué, le cours d’une action dépasseun seuil, etc.).

REMARQUE Notification et iPod touch

Les iPod touch bénéficient aussi de ce service, mais uniquement lorsque leur connexion réseau est active(c’est-à-dire qu’ils doivent être à portée d’une borne Wi-Fi et que leur écran doit être allumé).


Core ImageCe framework facilite la modification des caractéristiques d’une image, comme lateinte et l’exposition. Tous les iPad ont un co-processeur graphique (GPU) PowerVR(de ImgTec) qui rend ces opérations très rapides, y compris sur un flux vidéo.

Les effets, sous forme de filtres, peuvent être combinés et produisent des résultats detrès grande qualité.

L’environnement iOS fournit un très grand nombre de filtres applicables sur desimages. Dans l’exemple suivant, nous ne nous concentrerons que sur le filtreCIHueAdjust qui sert à modifier la teinte d’une image.

19Images, animations et graphiques

L’environnement iOS est très riche en fonctions graphiques. En s’appuyant surl’environnement Quartz, on dispose d’un nombre impressionnant de filtres d’images etd’animations faciles à mettre en place. L’API standard OpenGL ES (Embedded Systemspour environnements mobiles) est également disponible et permet d’aller encore plus loindans le contrôle du coprocesseur graphique, mais au prix d’une complexité accrue.

Classe Description

CIContext Contexte de travail dans lequel l’image est traitée.

CIImage Données de l’image. Par exemple depuis une UIImage ou un fichier.

CIFilter Cette classe est un dictionnaire qui donne la description du filtre correspondant.


CINQUIÈME PARTIE

La publication des applications

Cette dernière partie contient un seul chapitre, consacré à la publication des appli-cations sur l’App Store. Il est destiné à toute l’équipe projet qui y trouvera la listedes éléments à préparer avant de soumettre votre application, ainsi que des conseilspour favoriser les chances qu’elle soit validée du premier coup.

Enfin, nous y présentons quelques outils permettant de suivre le succès de l’applica-tion et d’en préparer la prochaine version.


Dans ce chapitre, nous aborderons tous les aspects de la publication, depuis la des-cription détaillée de l’ensemble des éléments à fournir lors de la soumission jusqu’à laliste des vérifications à effectuer avant l’envoi de l’application à Apple, sans omettre,bien sûr, de précieux conseils de lancement directement issus d’une expérience richeen publications.

Préparer les éléments marketing en vue de la publicationC’est au moment de la soumission que vous fournissez tous les éléments qui repré-sentent votre application dans l’App Store sur un appareil et dans iTunes. Du nomde l’application aux captures d’écran, en passant par l’icône de votre application, ilfaut porter autant d’attention à la préparation de ces éléments qu’à votre applicationelle-même.

20Publier sur l’App Store

La publication sur l’App Store est la dernière étape pour vous… mais la premièreapparition publique pour votre application. C’est le moment de préparer les éléments marketing qui feront le premier lien entre vosfuturs utilisateurs et votre application ; c’est aussi le moment de s’assurer que tout a bien étéfait. En effet, une fois la soumission effectuée, il n’est plus possible de retoucher votreapplication – sauf à recommencer l ’ensemble du processus de validation.



Index@end 29@implementation 29@interface 29@selector 35@synchronize 36

AAAC 286Ad Hoc 15addSubview: 160afconvert 286ALAC 286album photo 296alloc 31, 40animation 176APNS 301App Store 23, 331AppID 18application

didFinishLaunching 310didFinishLaunchingWithOptions: 310didReceiveRemoteNotification: 310

application utilitaire 93aps-environment 302ARC (Automatic Reference Counting) 39audioPlayerDidFinishPlaying:successfully: 288autoresizingMask 160AVAudioPlayer 287avertissement de mémoire 120AVFoundation 287

Bbadge 302barre d’onglets 97barre d’outils 93barre de navigation 95, 133, 137base de données 273

bibliothèque musicale 293boucle de gestion des évènements 48bounds 158

Ccaméra vidéo 296capture d’écran 338catégorie 336center 158centre de notification 291certificat de développeur 15certificat SSL 306chaîne de caractères 36charte graphique 80cible-action 126clavier 166clé de distribution 340commentaire 343comptage de références 39contact 221contrôle parental 337contrôleur de navigation 132coordonnées 157copyright 336Core Animation 176Core Audio 287Core Data 273, 313count 190

DData Access Object 273dealloc 40, 41délai d’attente 265délégué de l’application 48deleteObject: 284description de l’application 335description du modèle 276

Programmation iOS 6348


design pattern 183MVC 116

design pattern d’interface 87détection de contact 221deviceToken 303didFailToRegisterForRemoteNotificationsWith

Error: 303didRegisterForRemoteNotificationsWithDevice

Token: 303doigt 221dsym 342

Eécran de démarrage 50édition du modèle 280entité 276, 280entrepôt de stockage des données 277énumération 38erreur réseau 341

Ffeedback service 311fenêtre 44fichier audio 285fichier de propriétés 242fichier plist 242format audio 285formats de vidéos supportés 289Foundation 36frame 159

Ggéolocalisation 253glissement 227GPS 260graphe d’objets 275

HH264 289héritage 30

IIBAction 127icône 50, 145, 338id 28identifiant d’application 18

IMA4 286iMovie 104indicateur de position vertical 89Info.plist 48initialisateur 31insertNewObjectForEntityForName:inManaged

ObjectContext: 282internationalisation 178iPad 99, 104, 153iPod 293iTunes Connect 11

JJavaScript Object Notation 245JSON 245

Llangue principale 335largeur 192layoutSubviews 160lecture de vidéos 289Linear PCM 286lire des sons 287liste d’éléments 89liste groupée 195liste hiérarchique 94liste simple 195livre 100localisation 179, 340Localizable.strings 180

Mmain thread 266main() 47MapKit 253mapping objet-relationnel 273maquette graphique 81MediaPlayer 289Mercator 253message 27message de notification 308modèle 116, 276mouvement de doigt 222MP3 286MPMediaItem 294

Index 349


MPMediaItemCollection 294MPMediaPickerController 293MPMediaQuery 295MPMoviePlayerController 289, 290MPVolumeView 288MVC 116

NnetworkIndicatorVisible 268nil 28nom de l’application 50, 335nom de société 333notification 301NSArray 38, 39

writeToFile:atomically: 244NSDictionary 39NSEntityDescription 282NSError 264NSFetchRequest 282NSManagedObjectModel 276NSNotificationCenter 291NSObject 26

performSelector:withObject: 35respondsToSelector: 35

NSPersistentStoreCoordinator 277NSSortDescriptor 284NSString 36

stringWithFormat: 37NSURLRequest 264

connection:didFailWithError: 270connection:didFinishLoading: 270connection:didReceiveData: 270connection:didReceiveResponse: 270sendSynchronousRequest:returningResponse:

error: 264NSURLResponse 264NSUserDefaults 239NSXMLParser 248, 250

parser:didEndElement: 252parser:didStartElement: 250parser:foundCharacters: 251

OObject-Relational Mapping 273

objet persistant 276onglet 147openssl 306Organizer 22

PparentView 160pastille 302pathForResource:ofType: 244paysage 100performSelectorOnMainThread: 267personnalisation de la barre d’onglets 145photo 296PickerView 183pivoter 228plist 242pointeur sur fonction 35portra 100prédicat 283préférences utilisateur 239prix 339profil de provisionnement 20programme développeur 7propriété 32protocole 32publication 23, 82

QQuickTime 289

Rrecherche d’une entité 283registerForRemoteNotificationTypes: 303Réglages 241requête asynchrone 268requête réseau synchrone 264resignFirstResponder: 166retain 41reversement 339

Ssection 195segue 122sélecteur 35sélection 192

Programmation iOS 6350


service de notification 301setPersistentStoreCoordinator: 278SKU 336son 285spécifications 78SplitView 99SQL 273statistiques 343story boarding 78storyboard 117, 121streaming 292strong 41style de cellule

UITableViewCellStyleDefault 199UITableViewCellStyleValue1 199UITableViewCellStyleValue2 199UITableViewCellSubtitle 199

supprimer un objet 284swipe 227symbole 342

Ttarget-action 126téléchargement 343thread 36thread principal 266transform 159transition 122

UUIApplication 48, 303UIApplicationDelegate

applicationDidBecomeActive: 54applicationDidFinishLaunching: 48, 52applicationDidReceiveMemoryWarning: 53applicationWillResignActive: 54applicationWillTerminate: 53

UIApplicationMain 48UIBarButtonItem 135UIButton 165UIImage 164UIImagePickerController 296UIImagePickerControllerDelegate 298UIImageView 164

UILabel 163UINavigationController 132

pushViewController:animated: 136UINavigationItem 134UISplitViewController 131UITabBarController 145UITabBarControllerDelegate 146UITableView 196

dequeueReusableCellWithIdentifier 198initWithFrame:style: 196rowHeight 203

UITableViewCell 198UITableViewDelegate 200

tableView:heightForRowAtIndexPath: 203UITableViewSource

numberOfSectionsInTableView: 198tableView:cellForRowAtIndexPath: 198tableView:numberOfRowsInSection: 198tableView:titleForFooterInSection: 200tableView:titleForHeaderInSection: 200

UITextField 166, 167UITextFieldDelegate 166, 171UITouch 222UIView

frame 65UIViewController 129

didReceiveMemoryWarning 120dismisssModalViewControllerAnimated: 152hidesBottomBarWhenPushed 136loadView 119modalTransitionStyle 152navigationItem 134parentViewController 152presentModalViewController:animated: 151shouldAutorotateToInterfaceOrientation: 128viewDidAppear: 119, 126viewDidDisappear: 120viewDidLoad 119, 124viewDidUnload: 120viewWillAppear: 119, 126viewWillDisappear: 120

UIWebView 176

Index 351


Vvalidation 342variable d’instance 30version 336vidéo 296vidéo en streaming 292viewWithTag: 204volume de lecture 287

volume système 288vue modale 150

WWebKit 176

XXcode 43XML 248

programmation ios 6 - fnac-static.com...après le succès sans précédent de l’iphone en 2007,...

Documents