Project:Omega.org

D’un point de vue général, le processus de création d’une application pour iPhone est similaire à celui de création d’une application Mac OS X. Les deux se servent des mêmes outils et de la plupart des bibliothèques de base. Malgré ces similitudes, il y a aussi des différences significatives. Un iPhone n’est pas un ordinateur de bureau ; son but est différent et nécessite une approche de conception très différente. Cette approche nécessite de tirer profit des capacités de iPhone OS et de se priver de fonctionnalités qui pourraient se révéler non pertinentes ou non pratiques dans un environnement mobile. La taille plus petite des écrans de l’iPhone et de l’iPod Touch signifie aussi que votre interface utilisateur devra être bien organisée et qu’elle devra toujours se concentrer sur les données dont l’utilisateur a le plus besoin.

iPhone OS permet aux utilisateurs d’interagir avec les iPhone et les iPod Touch selon des schémas que l’on ne peut reproduire avec des applications classiques. L’interface Multi-Touch est une nouvelle approche révolutionnaire dans la manière de recevoir des événements, permettant une gestion distincte pour chaque doigt qui touche l’écran et autorisant ainsi des gestes à plusieurs doigts ainsi que d’autres entrées de données complexes, le tout facilement. De plus, les fonctions intégrées au matériel telle que l’accéléromètre, bien que présent dans certains systèmes de bureau, sont utilisées de façon plus intensive dans iPhone OS pour pister l’orientation actuelle de l’écran et pour appliquer un ajustement à l’affichage du contenu. La compréhension de la manière d’utiliser ces fonctions vous aidera à vous concentrer sur une conception qui sera pertinente pour vos utilisateurs.

La meilleure façon de comprendre la conception d’une application pour iPhone est de regarder un exemple. Cet article vous emmène dans une visite de l’exemple applicatif appelé MoveMe. Cet exemple illustre de nombreux comportements typiques adoptés par une application iPhone, à savoir :

• Initialiser l’application
• Afficher une fenêtre
• Dessiner des contenus personnalisés
• Gérer des événements de touché
• Effectuer des animations

La Figure 1 vous montre l’interface de l’application. Le fait de toucher le bouton Welcome déclenche une animation qui provoque une pulsation du bouton et son centrage sous votre doigt. Au fur et à mesure que vous déplacez votre doigt sur l’écran, le bouton suit votre doigt. Si vous écartez votre doigt de l’écran, une autre animation est alors jouée et le bouton retrouve sa position originelle. Un tapement double n’importe où en dehors du bouton provoque le changement de langue du message de salutation du bouton.

Figure 1  La fenêtre de l’application MoveMe

Avant d’aller plus loin, vous devriez télécharger l’exemple traité (MoveMe) de façon à pouvoir suivre le tout directement dans le code source. Vous devriez aussi lire les pages d’orientation suivantes issues de l’iPhone Dev Center afin d’avoir une compréhension basique de iPhone OS, des outils et du langage que vous utiliserez pour le développement :

• Vue d’ensemble de iPhone OS
• Les outils de développement pour iPhone

Si vous ne connaissez pas bien le langage Objective-C, vous devriez aussi lire Learning Objective-C: A Primer pour vous familiariser avec la syntaxe de ce langage. (NdT : Plusieurs tutoriels sont disponibles sur Project:Omega à cette adresse).

Examen du Projet MoveMe

Le téléchargement de MoveMe vous apporte le code source et les fichiers support requis pour construire et lancer l’application. Vous gérez des projets pour iPhone OS en utilisant l’application Xcode (localisée dans /Developer/Applications par défaut). Chaque projet Xcode sont la combinaison d’un espace de travail dont le but est de rassembler votre code et les fichiers ressources, de règles de construction pour la compilation du code source et l’assemblage de l’application, ainsi que d’outils d’édition et de debugging.

La Figure 2 montre la fenêtre Xcode du projet MoveMe. Pour ouvrir ce projet, copiez le sur votre disque dur local et double-cliquez sur le fichier MoveMe.xcodeproj. (Vous pouvez aussi ouvrir le projet à l’intérieur de Xcode en sélectionnant File > Open et en choisissant le fichier.) Le projet comprend plusieurs fichiers source Objective-C (avec l’extension .m), des fichiers nib (avec l’extension .xib), quelques fichiers image et autres ressources, ainsi qu’une cible prédéfinie (MoveMe) pour construire le paquet applicatif.

Figure 2  La fenêtre du projet MoveMe

Dans iPhone OS, le but ultime de votre projet Xcode est de construire un paquet applicatif, paquet qui est en fait un type spécial de répertoire qui héberge l’exécutable binaire de votre application et les fichiers de ressources. Les paquets dans iPhone OS ont une structure de répertoire relativement plate, avec la plupart des fichiers placés à la racine du répertoire. Cependant, un paquet peut également contenir des sous-répertoires pour stocker des versions localisées de chaînes de caractères et d’autres fichiers ressource spécifiques à la langue. Vous n’avez pas besoin de connaître la structure exacte du paquet applicatif pour poursuivre ce présent article, mais vous pouvez trouver ces informations dans iPhone Application Programming Guide si cela vous intéresse.

Construction de l’Application MoveMe

Pour construire l’application MoveMe et l’exécuter dans le simulateur, procédez comme suit :

1. Ouvrez le fichier MoveMe.xcodeproj dans Xcode.
2. Dans la barre d’outils du projet, assurez-vous que l’option simulateur est sélectionnée dans le menu Active SDK. (Si le menu Active SDK n’apparaît pas dans la barre d’outils, choisissez Project > Set Active SDK > Simulator.)
3. Sélectionnez Build > Build and Go (Run) à partir de ce menu, ou cliquez simplement sur le bouton Build and Go de la barre d’outils.

Lorsque la construction de l’application est terminée, Xcode la charge dans le simulateur d’iPhone et l’exécute. En utilisant votre souris, vous pouvez cliquer sur le bouton Welcome et le faire glisser sur l’écran pour voir le comportement de l’application. Si vous disposez d’un périphérique configuré pour le développement, vous pouvez aussi créer votre application et l’exécuter sur ce dispositif. Pour plus d’informations sur la façon de configurer les périphériques pour le développement et le chargement d’applications, reportez-vous à iPhone Development Guide

Un mot à propos de la gestion de la mémoire

iPhone OS est avant tout un système orienté-objet, de sorte que la plupart de la mémoire que vous allouez l’est sous la forme d’objets Objective-C. Les objets dans iPhone OS utilisent un système de comptage de référence pour savoir à quel moment il est conseillé de libérer la mémoire occupée par l’objet. Lorsque vous créez un objet, il commence avec un numéro de référence à 1. Les clients qui reçoivent cet objet peuvent opter de le conserver, ce qui augmente son numéro de référence de 1. Si le client conserve un objet, le client doit également libérer cet objet quand il n’est plus utile. La libération d’un objet décrémente son numéro de 1. Quand le numéro de référence d’un objet est égale à 0, le système récupère automatiquement la mémoire de l’objet.

	iPhone OS ne prend pas en charge la gestion de la mémoire en utilisant la fonction de collecte des déchets qui est utilisée sous Mac OS X v10.5 et ultérieur

Si vous voulez allouer des blocs de mémoire générique, —c’est à dire, de la mémoire non associée à un objet—, vous pouvez le faire en appelant la bibliothèque standard malloc. Comme c’est le cas pour toute mémoire allouée en utilisant malloc, vous êtes responsable de la libération de cette mémoire que lorsque vous en avez fini avec elle en appelant la fonction free. Le système ne libère pas des blocs qui ont été alloués par malloc à votre place.

Indépendamment de la façon dont vous allouez de la mémoire, la gestion globale de votre utilisation de la mémoire est plus importante dans iPhone OS que dans Mac OS X. Bien que iPhone OS soit doté d’un système de mémoire virtuelle, il n’utilise pas de fichier swap. Cela signifie que des pages de codes peuvent être traitées au besoin, mais que les données de votre application doivent toutes tenir dans la mémoire au même moment. Le système surveille la quantité de mémoire libre et fait ce qu’il peut pour donner à votre application la mémoire dont elle a besoin. Cependant, si l’utilisation de la mémoire devient trop critique, le système peut mettre un terme à votre application. Toutefois, cette option n’est utilisée qu’en dernier recours, pour s’assurer que le système dispose de suffisamment de mémoire pour effectuer des opérations critiques telles que la réception d’appels téléphoniques.

Pour plus d’informations sur la manière d’allouer de la mémoire dans iPhone OS, reportez-vous à Cocoa Fundamentals Guide. Pour des informations et des astuces sur la manière d’optimiser l’utilisation de la mémoire de votre application, repotez-vous à “Using Memory Efficiently” dans iPhone Application Programming Guide.

Initialisation de l’application the MoveMe

Comme pour toute application écrite en C, le point d’entrée initial pour toute application iPhone est une fonction appelée main. La bonne nouvelle est que lorsque vous créez un nouveau projet en utilisant les modèles iPhone de Xcode, vous n’avez pas à écrire vous même cette fonction. Les modèles de projet comprennent une version de cette fonction avec tout le code nécessaire pour démarrer votre application.

Le Listing 1 montre la fonction main de l’application MoveMe. La fonction main est située dans le fichier projet main.m. Chaque application que vous créerez aura une fonction main qui sera presque identique à celle-ci. Cette fonction effectue deux tâches principales. Tout d’abord, elle crée le bassin d’auto-destruction de haut niveau de l’application, dont le but est de récupérer la mémoire des objets Objective-C qui ont été libérés en appelant la méthode autorelease. Ensuite, elle appelle la fonction UIApplicationMain pour créer les objets clés de l’application MoveMe, initialiser ces objets et enclencher la boucle de traitement des événements. L’application ne sort pas de cette fonction jusqu’à ce qu’elle soit quittée.

Listing 1  Utilisation de la fonction main fournie

int main(int argc, char *argv[])
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    int retVal = UIApplicationMain(argc, argv, nil, nil);
    [pool release];
    return retVal;
}

Creation du Délégué de l’Application

Une des plus importantes notions architecturales d’une application iPhone est la définition de l’objet délégué de l’application. La plupart des modèles de projet Xcode créer cet objet automatiquement, fournissant un squelette de classe que vous pouvez modifier au besoin pour définir le comportement de votre application. Dans le projet MoveMe, l’interface de la classe du délégué de l’application est dans MoveMeAppDelegate.h et son implémentation est dans MoveMeAppDelegate.m.

Votre objet délégué fonctionne en tandem avec l’objet standard UIApplication afin de répondre aux changements de conditions de l’application. L’objet application effectue le gros du travail, mais le délégué a à charge plusieurs comportements, à savoir :

• Réglages initiaux de la fenêtre de l’application et de l’interface utilisateur
• Toute tâche supplémentaire requise par votre moteur propre de données
• Répondre aux interruptions, telles que les appels téléphoniques ou les messages SMS
• Réponse à des situations de mémoire insuffisante en libérant de la mémoire supplémentaire
• Quitter l’application à la demande du système
• Traiter les URL transmises à l’application par des sources externes
• Répondre aux changements d’orientation de l’appareil

Au lancement, la préoccupation la plus immédiate pour l’objet délégué est de créer et présenter la fenêtre de l’application à l’utilisateur, processus qui est décrit dans “Création de la fenêtre de l’application”. Le délégué peut également effectuer toutes les tâches nécessaires pour préparer l’application à une utilisation immédiate, comme la restauration de l’application dans un état antérieur ou la création de tous les objets requis. Lorsque l’application quitte, le délégué doit exécuter un arrêt ordonné de l’application et sauvegarder toute information concernant l’état actuel en vue d’un prochain lancement.

Le principal fichier nib de votre projet est habituellement le lieu où l’association entre l’objet application et l’objet délégué est créée. Un fichier nib est un fichier de ressource que contient essentiellement un ensemble d’objets congelés. Vous créez et éditez tout fichier nib à l’aide de l’application Interface Builder, en précisant les objets que vous souhaitez charger au moment de l’exécution de votre application. Lorsque votre application charge un fichier nib lors de son exécution, le code de chargement du nib recrée automatiquement les objets dans ce fichier nib, les configure exactement comme ils l’étaient dans Interface Builder, et les rend disponibles pour une utilisation dans votre application.

Dans l’application MoveMe, le fichier nib principal contient une instance de la classe MoveMeAppDelegate et aussi un lien entre cet objet et l’objet standard UIApplication. Un double-clic sur le fichier MainWindow.xib du projet MoveMe provoque le lancement d’Interface Builder et l’ouverture du fichier nib. La sélection de l’icône File’s Owner (qui représente l’objet UIApplication) et l’ouverture de l’inspecteur des connexions (comme le montre la figure 3) révèle la connexion entre l’application et le délégué. L’objet File’s Owner est aussi connu sous le nom d’objet “proxy”, car il agit comme un emplacement pour objet fourni au moment de l’exécution par votre application. D’autre part, l’objet MoveMeAppDelegate est créé au cours du processus de chargement du nib.

Figure 3  Le délégué de l’application

Pour plus d’informations à propos de l’architecture fondamentale et des cycles de vie d’une application iPhone, y compris le rôle joué par les fichiers nib, voir “The Core Application” dans iPhone Application Programming Guide. Pour en savoir plus sur la façon de créer des fichiers nib dans Interface Builder, voir Interface Builder User Guide.

Création de la fenêtre de l’application

Toute application est chargée de créer une fenêtre qui couvre la totalité de l’écran et de remplir cette fenêtre avec du contenu. Les applications graphiques tournant sous iPhone OS ne tournent pas aux côtes d’autres applications. En fait, à part le noyau et quelques démons système de bas-niveau, votre application est la seule chose qui tourne après son lancement. De plus, votre application ne devrait jamais nécessiter plus d’une fenêtre—une instance de la classe UIWindow. Dans certaines situations où vous aurez à modifier votre interface utilisateur, vous modifierez alors les vues affichées par votre fenêtre.

Les fenêtres fournissent la surface de dessin à votre interface utilisateur, mais les objets vue fournissent le contenu réel. Un objet vue est une instance de la classe UIView qui dessine un peu de contenu et répond à des interactions avec ce contenu. iPhone OS définit des vues standard pour représenter les choses telles que des tableaux, des boutons, des champs de texte et d’autres types de contrôles interactifs. Vous pouvez ajouter ces vues à votre fenêtre, ou vous pouvez définir des vues personnelles en sous-classant la classe UIView et en implémentant une peu de code de dessin et de gestion des événements. L’application MoveMe définit deux de ces vues—représentées par les classes MoveMeView et PlacardView— pour afficher l’interface de l’application et gérer les interactions.

Au moment du lancement, le but est de créer une fenêtre d’application et d’afficher quelques contenus initiaux aussi vite que possible. L’objet fenêtre est extrait du fichier nib MainWindow.xib. Lorsque l’application atteint l’état où l’on considère qu’elle est lancée et prête à traiter des événements, l’objet UIApplication envoie un message applicationDidFinishLaunching: au délégué. Ce message est le signal qui indique au délégué qu’il peut commencer à placer du contenu dans sa fenêtre et effectuer toute autre initialisation que l’application pourrait nécessiter.

Dans l’application MoveMe, la méthode applicationDidFinishLaunching: du délégué effectue ce qui suit :

1. Elle crée un objet contrôleur de vues dont le boulot consiste à gérer la vue contenu de la fenêtre.
2. Elle initialise le contrôleur de vues à partir du nom du fichier nib (MoveMeView.xib) dont elle va gérer le contenu. (Le fichier MoveMeView.xib contient la vue à afficher dans la fenêtre.)
3. Elle ajoute la vue du contrôleur en tant que sous-vue de la fenêtre.
4. Elle affiche la fenêtre.

Le listing 2 montre la méthode applicationDidFinishLaunching: de l’application MoveMe, qui est définie dans le fichier d’implémentation du délégué de l’application MoveMeAppDelegate.m. Cette méthode crée la vue principale de contenu de la fenêtre et rend la fenêtre visible. L’affichage de la fenêtre indique au système que votre application est prête à gérer des événements.

Listing 2  Création de la vue contenu

- (void)applicationDidFinishLaunching:(UIApplication *)application
{
    // Réglage du contrôleur de vue
    UIViewController *aViewController = [[UIViewController alloc]
               initWithNibName:@"MoveMeView" bundle:[NSBundle mainBundle]];
    self.viewController = aViewController;
    [aViewController release];
    // Ajout de la vue du contrôleur sous forme de sous-vue de la fenêtre
    UIView *controllersView = [viewController view];
    [window addSubview:controllersView];
    [window makeKeyAndVisible];
}

Bien que le code précédent crée la vue arrière-plan de la fenêtre puis affiche la fenêtre, ce que vous ne voyez pas dans le code précédent est la création de la classe PlacardView qui affiche le bouton d’accueil. La classe PlacardView est instanciée implicitement lorsque l’objet MoveMeView est chargé à partir de son fichier nib. Au cours du chargement du fichier nib, l’objet MoveMeView est initialisé en utilisant sa méthode initWithCoder:. Cette méthode appelle alors la méthode setUpPlacardView (illustrée dans le Listing 3), qui gère la création et la configuration de l’objet PlacardView. L’objet PlacardView est configuré comme une sous-vue de l’objet MoveMeView. Cette relation provoque l’affichage du bouton d’accueil au niveau le plus haut de l’application et autorise l’objet MoveMeView à gérer les événements qui sont dirigés vers le bouton d’accueil.

Listing 3  Création de la vue placard

- (void)setUpPlacardView
{
    // Création de la vue placard -- elle calcule son propre cadre en sa basant sur son image
    PlacardView *aPlacardView = [[PlacardView alloc] init];
    self.placardView = aPlacardView;
    [aPlacardView release];
    placardView.center = self.center;
    [self addSubview:placardView];
}

Pour plus d’informations sur la création des fenêtres et des vues, voir “Windows and Views” dans iPhone Application Programming Guide.

Dessin du bouton d’accueil

Les vues standard fournies par UIKit peuvent être utilisées sans modification afin de dessiner de nombreux types de contenu simple. Par exemple, vous pouvez utiliser la classe UIImageView pour afficher des images et la classe UILabel pour afficher des chaînes de texte. La classe MoveMeView de l’application MoveMe profite aussi d’une propriété fondamentale de tous les objets UIView—en particulier, la propriété backgroundColor—pour remplir la vue d’une couleur unie. Cette propriété peut être définie dans le code dans la méthode d’initialisation de l’objet. Dans l’application MoveMe, la propriété est définie à l’intérieur du fichier nib MoveMeView.xib. L’attribut de couleur de l’objet MoveMe est positionné en utilisant l’onglet Attributs de la fenêtre Inspecteur dans Interface Builder. Si vous avez besoin de dessiner dynamiquement du contenu, vous devez utiliser les fonctionnalités plus avancées de dessin fournies par UIKit ou vous devez utiliser Quartz ou OpenGL ES.

La classe PlacardView de l’application MoveMe dessine le bouton d’accueil et gère son emplacement à l’écran. Bien que cette classe pourrait dessiner son contenu en utilisant un objet UIImageView et un objet UILabel, elle dessine le contenu de façon explicite, afin de démontrer l’ensemble du processus. En conséquence, cette classe implémente une méthode drawRect:, lieu où tout dessin personnalisé pour une vue prend place.

Au moment où une méthode drawRect: est appelée, l’environnement de dessin est configuré et prêt à l’emploi. Tout ce que vous avez à faire est de spécifier les commandes qui permettront de dessiner tout contenu personnalisé. Dans la classe PlacardView, le contenu consiste en une image de fond (stockée dans le fichier ressource Placard.png) et en une chaîne de caractères, le texte qui peut changer dynamiquement. Pour dessiner ce contenu, la classe suit les étapes suivantes :

1. Dessin de l’image d’arrière-plan à la position actuelle. (Du fait que la vue est déjà taillée pour accueillir l’image, cette étape apport l’arrière-plan complet du bouton.)
2. Calcul de la position de la chaîne de caractères de façon à la centrer sur le bouton. (Du fait que la chaîne puisse changer, la position doit être recalculée en se basant sur la taille de la chaîne)
3. Réglage de la couleur de dessin sur le noir.
4. Dessin de la chaîne en noir et de façon légèrement décalée.
5. Réglage de la couleur de dessin sur le blanc.
6. Dessin de la chaîne en blanc à la position attendue.

Le listing 4 montre la méthode drawRect: de la classe PlacardView. La variable membre placardImage contient un objet UIImage pour l’arrière-plan du bouton et la variable membre currentDisplayString est un objet NSString contenant la chaîne de bienvenue. Après avoir dessiné l’image, cette méthode calcule la position de la chaîne au sein de la vue. La taille de la chaîne est déjà connue, car elle a été calculée au moment où la chaîne a été chargée et stockée dans la variable membre textSize. La chaîne est alors dessinée deux fois—une fois en noir et une fois blanc— en utilisant la méthode drawAtPoint:forWidth:withFont:fontSize:lineBreakMode:baselineAdjustment: de la classe NSString.

Listing 4  Dessin du bouton d’accueil

- (void)drawRect:(CGRect)rect
{
    // Dessin de l'affiche à la position 0, 0
    [placardImage drawAtPoint:(CGPointMake(0.0, 0.0))];
    /*
     Dessine la chaîne d'affichage.
     Cela pourrait être effectué en utilisant UILabel, mais cela sert à illustrer
     les extensions UIKit de NSString. Le texte est dessiné deux fois au centre de la vue
     une fois en noir, une fois en blanc, pour donner une apparence décalée. La taille de
     la police et du texte sont calculées dans setupNextDisplayString.
     */
    // Recherche du point à partir duquel dessiner la chaîne de façon à ce qu'elle soit centrée
    CGFloat x = self.bounds.size.width/2 - textSize.width/2;
    CGFloat y = self.bounds.size.height/2 - textSize.height/2;
    CGPoint point;
    // Police à la bonne taille
    UIFont *font = [UIFont systemFontOfSize:fontSize];
    [[UIColor blackColor] set];
    point = CGPointMake(x, y + 0.5);
    [currentDisplayString drawAtPoint:point
                forWidth:(self.bounds.size.width-STRING_INDENT)
                withFont:font
                fontSize:fontSize
                lineBreakMode:UILineBreakModeMiddleTruncation
                baselineAdjustment:UIBaselineAdjustmentAlignBaselines];
    [[UIColor whiteColor] set];
    point = CGPointMake(x, y);
    [currentDisplayString drawAtPoint:point
                forWidth:(self.bounds.size.width-STRING_INDENT)
                withFont:font
                fontSize:fontSize
                lineBreakMode:UILineBreakModeMiddleTruncation
                baselineAdjustment:UIBaselineAdjustmentAlignBaselines];
}

Quand vous avez besoin de dessiner un contenu plus complexe que des images et des chaînes de caractères, vous pouvez utiliser Quartz ou OpenGL ES. Quartz fonctionne avec UIKit pour le dessin de tracés vectoriels, d’images, de dégradés, de PDF et autres contenus complexes que vous souhaiterez créer dynamiquement. Du fait que Quartz et UIKit Quartz soient basés sur le même environnement de dessin, vous pouvez appeler directement les fonctions Quartz à partir de la méthode drawRect: de votre vue et même combiner des appels Quartz équivalents avec des appels UIKit.

OpenGL ES est une solution alernative à Quartz et UIKit qui vous permet le rendu de contenus 2D et 3D en utilisant un ensemble de fonctions qui ressemblent (mais ne sont pas exactement similaires) à celles trouvées dans OpenGL pour Mac OS X. Contrairement à Quartz et UIKit, vous n’utilisez pas la méthode drawRect: de votre vue pour effectuer le dessin. Vous utilisez toujours une vue mais vous utilisez cet objet vue essentiellement pour fournir une surface de dessin à votre code OpenGL ES. Vous n’avez qu’à décider combien de fois vous mettez à jour la surface de dessin, et quels objets vous utilisez pour le faire.

Pour plus d’informations sur chacune de ces technologies de dessin et sur la façon dont s’en servir, reportez-vous à “Graphics and Drawing” dans iPhone Application Programming Guide.

Gestion des événements de touché

L’interface Multi-Touch de iPhone OS permet à votre application de reconnaître des événements différents générés par des touchés à plusieurs doigts et d’y répondre. Cette faculté à répondre à ces types d’événements offre une puissance considérable mais représente aussi une différence significative par rapport à la façon traditionnelle de gérer les événements basés sur la souris. A chaque touché de chaque doigt sur la surface de l’appareil, le détecteur de contact génère un nouvel événement de touché. A chaque déplacement de doigt, des événements supplémentaires sont générés pour la nouvelle position du doigt. Quand un doigt s’écarte de la surface de l’appareil, le système transmet encore un autre événement pour indiquer ce fait.

Sachant qu’il peut y avoir plusieurs doigts touchant l’appareil en même temps, il vous est possible d’utiliser ces événements pour identifier des gestes complexes. Lorsque le gestionnaire d’événements système génère un nouvel événement de touché, il donne des informations sur l’état actuel de chaque doigt que ce doigt ait touché ou qu’il se soit écarté de l’appareil. Ainsi, vous pouvez surveiller les actions de chaque doigt à chaque arrivée d’événement. Vous pouvez alors suivre les mouvements de chaque doigt d’événement en événement pour détecter des gestes, que vous pouvez appliquer sur le contenu de votre application. Par exemple, si les événements indiquent que l’utilisateur effectue un geste de pincée ou d’écartement de doigts (comme le montre la figure 4) et que la vue prend en charge le zoom, vous pouvez utiliser ces événements pour modifier le niveau de zoom actuel.

Figure 4  Utilisation d’événements de touché pour détecter des gestes

Le système fournit des événements aux objets répondeur de l’application qui sont des instances de la classe UIResponder. Dans une application iPhone, les vues de votre application sont l’essentiel de vos objets répondeur. L’application MoveMe met en oeuvre deux classes de vue, mais seule la classe MoveMeView répond effectivement aux messages événementiels. Cette classe détecte les tapotements à la fois à l’intérieur et en dehors des limites du bouton d’accueil en surclassant les méthodes suivantes de UIResponder :

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event;
- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event;
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event;

Afin de simplifier le comportement de son propre gestionnaire d’événements, l’application MoveMe ne s’intéresse seulement qu’au premier doigt qui touche la surface de l’appareil. Elle le fait avec le soutien de la classe UIView, ce qui, par défaut, n’autorise pas les événements de touchés multiples. Pour les applications qui n’ont pas à se soucier de plusieurs doigts, cette fonctionnalité est très commode. Quand les événements à touchés multiples sont désactivés, le système ne délivre que des événements relatifs au premier doigt ayant touché l’appareil. Les événements liés à d’autres touchés au sein d’une séquence ne sont jamais délivrés à la vue. Cependant, si vous souhaitez obtenir des informations sur ces touchés supplémentaires, vous pouvez réactiver le touché multiple à l’aide de la méthode setMultipleTouchEnabled: de la classe UIView.

Dans son gestionnaire d’événements, la classe MoveMeView effectue les actions suivantes :

1. Lorsqu’un touché arrive pour la première fois, il en contrôle sa position.
   • Les tapotements doubles en dehors du bouton d’accueil modifient la chaîne de caractères affichées dans le bouton.
   • Les tapotements simples à l’intérieur du bouton provoque le centrage du bouton sous le doigt et déclenche une animation qui agrandit le bouton.
   • Tous les autres touché sont ignorés.
2. Si le doigt se déplace en étant à l’intérieur du bouton, la position du bouton est modifiée en conséquence.
3. Si le doigt était à l’intérieur du bouton et qu’il s’écarte de l’appareil, une animation renvoie le bouton à sa position originelle.

Le listing 5 montre la méthode touchesBegan:withEvent: de la classe MoveMeView. Le système appelle cette méthode lorsque le doigt touche l’appareil la première fois. Cette méthode obtient l’ensemble des touchés et en extrait le seule et unique objet de touché. Les informations contenues dans l’objet UITouch sont utilisées pour identifier la vue dans lequel le touché a eu lieu (l’objet MoveMeView ou l’objet PlacardView) et le nombre de tapotements associés au contact. Si le touché représente un tapotement double en dehors du bouton, la méthode touchesBegan:withEvent: appelle la méthode setupNextDisplayString pour changer de chaîne de caractères du bouton. Si l’événement a eu lieu à l’intérieur du bouton d’accueil, elle utilise la méthode animateFirstTouchAtPoint: pour agrandir le bouton et le suivre à sa nouvelle position. Tous les autres événements liés au touché sont ignorés.

Listing 5  Gestion d’un événement initial de touché

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    // Nous ne supportons que les touchés simples, ainsi tout objet
    // ne recueille qu'un seul touché parmi tant d'autres
    UITouch *touch = [touches anyObject];
    // Déplacement de la vue si le touché était dans la vue
    if ([touch view] != placardView)
    {
        // En cas de double tapotement en dehors de la vue, on met à jour la chaîne de caractère
        if ([touch tapCount] == 2)
        {
            [placardView setupNextDisplayString];
        }
        return;
    }
    // Animation du premier touché
    CGPoint touchPoint = [touch locationInView:self];
    [self animateFirstTouchAtPoint:touchPoint];
}

Le listing 6 montre la méthode touchesMoved:withEvent: de la classe MoveMeView. Le système appelle cette méthode, après que le doigt ait touché l’appareil et en réponse déclenche un mouvement à partir de son emplacement d’origine. L’application ne suit que les mouvements qui se produisent au sein du bouton d’accueil. En conséquence, cette méthode vérifie le lieu de l’événement et l’utilise pour régler le point central de l’objet PlacardView. Le mouvement de la vue fait que la vue est redessinée automatiquement à sa nouvelle position.

Listing 6  Réponse au mouvement après un touché

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
    UITouch *touch = [touches anyObject];
    // Si le touché était dans le placardView, on déplace placardView à la position du touché
    if ([touch view] == placardView)
    {
        CGPoint location = [touch locationInView:self];
        placardView.center = location;
        return;
    }
}

Lorsque le doigt de l’utilisateur finit par s’écarter de l’écran, l’application MoveMe répond en déclenchant une animation de déplacement du bouton vers sa position de départ au centre de la fenêtre de l’application. Le listing 7 montre la méthode touchesEnded:withEvent: qui déclenche l’animation.

Listing 7  Relachement du bouton d’accueil

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
    UITouch *touch = [touches anyObject];
    // Si le touché était dans le placardView, on le ramène au centre
    if ([touch view] == placardView)
    {
        // On désactive les interactions utilisateur de façon à ce que les touchés suivants
        // n'interfère pas avec l'animation
        self.userInteractionEnabled = NO;
        [self animatePlacardViewToCenter];
        return;
    }
}

Afin de simplifier le processus de traitement des événements, la méthode touchesEnded:withEvent: désactive temporairement les événements de touché tandis que le bouton est ramené à sa position initiale. Si elle ne le faisait pas, chacune des méthodes de gestion d'événements auraient du inclure un peu de logique afin de déterminer si le bouton est au milieu de l'animation et, le cas échéant, annuler l'animation. Le fait de désactiver les interactions de l'utilisateur durant le court moment où le bouton voyage vers le centre de l'écran simplifie le code de gestion des événements et élimine le besoin de cette logique supplémentaire. Au moment d'arriver à sa position initiale, la méthode animationDidStop:fini: de la classe MoveMeView autorise de nouveau les interactions de l’utilisateur afin que le cycle d’événement puisse redémarrer encore une fois.

Pour plus d’informations sur la gestion des événements dans iPhone OS, reportez-vous à “Event Handling” dans iPhone Application Programming Guide.

Animer le mouvement du bouton

Dans les applications iPhone, une animation joue un rôle très important. Les animations sont utilisées intensivement pour apporter à l’utilisateur des informations contextuelles et un retour immédiat. Par exemple, lorsque l’utilisateur navigue dans les données hiérarchisées d’une application en rapport avec la productivité, au lieu de simplement remplacer un écran par un autre, les applications iPhone effectue des changements d’écran avec une animation. La direction du mouvement donne une indication sur le sens de la navigation au sein de la hiérarchie et attire aussi l’attention sur une nouvelle information à examiner.

Du fait de leur importance, les animations sont déjà supportées par des classes du UIKit. L’application MoveMe tire profit de ce support en l’utilisant pour animer les différents aspects du bouton d’accueil. Lorsque l’utilisateur touche la première fois le bouton, l’application applique une animation qui a pour effet d’agrandir le bouton brièvement. Lorsque l’utilisateur s’écarte du bouton, une autre animation ramène le bouton à sa position originale. Les étapes basiques de création de ces animations sont essentiellement les mêmes :

1. Appel de la méthode beginAnimations:context: de la vue que vous souhaitez animez.
2. Configuration des propriétés de l’animation.
3. Appel de la méthode commitAnimations de la vue pour démarrer l’animation.

Le listing 8 montre le code de l’animation utilisé pour faire vibrer le bouton Welcome lorsqu’il est touché pour la première fois. Cette méthode règle la durée de l’animation puis applique une transformation au bouton qui le fait passer à sa nouvelle taille. Lorsque cette animation est terminée, l’infrastructure de l’animation appelle la méthode growAnimationDidStop:finished:context: du délégué de l’animation, qui termine l’animation en rétrécissant un peu le bouton et en le déplaçant sous le doigt.

Listing 8  Animation du bouton Welcome

- (void)animateFirstTouchAtPoint:(CGPoint)touchPoint
{
#define GROW_ANIMATION_DURATION_SECONDS 0.15
    NSValue *touchPointValue = [[NSValue valueWithCGPoint:touchPoint] retain];
    [UIView beginAnimations:nil context:touchPointValue];
    [UIView setAnimationDuration:GROW_ANIMATION_DURATION_SECONDS];
    [UIView setAnimationDelegate:self];
    [UIView setAnimationDidStopSelector: @selector(growAnimationDidStop:finished:context:)];
    CGAffineTransform transform = CGAffineTransformMakeScale(1.2, 1.2);
    placardView.transform = transform;
    [UIView commitAnimations];
}
- (void)growAnimationDidStop:(NSString *)animationID finished:(NSNumber *)finished context:(void *)context
{
    #define MOVE_ANIMATION_DURATION_SECONDS 0.15
    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationDuration:MOVE_ANIMATION_DURATION_SECONDS];
    placardView.transform = CGAffineTransformMakeScale(1.1, 1.1);
    // Déplacement de la vue sous le doigt
    NSValue *touchPointValue = (NSValue *)context;
    placardView.center = [touchPointValue CGPointValue];
    [touchPointValue release];
    [UIView commitAnimations];
}

Pour plus d’infos sur l’utilisation des animations intégrées des vues, voir “Animating Views” dans iPhone Application Programming Guide. Pour plus d’infos sur Core Animation, voir “Applying Core Animation Effects” dans iPhone Application Programming Guide.

Finition de l’Application

Dans les sections précédentes, vous avez vu comment l’application MoveMe a été initialisée, comment elle a présenté son interface utilisateur et répondu à des événements. En plus de ces aspects de création de l’application, il y a aussi d’autres petits détails qui doivent être pris en considération avant de construire et de charger une application sur un appareil. L’une des dernières pièces à mettre en place est la liste de propriétés de votre application (Info.plist). Il s’agit d’un fichier XML qui communique des renseignements de base sur votre application au système. Xcode crée une version par défaut de ce fichier et y insère les informations de configuration initiales nécessaires à votre application. Vous pouvez développer ces informations, cependant, afin de fournir au système des détails qu’il devrait connaître. Par exemple, vous pouvez utiliser ce fichier pour communiquer des informations sur la version de votre application, les URL personnalisées qu’elle accepte, son icône de lancement, le statut de visibilité par défaut et le style de la barre d’état système.

Le listing 9 présente le contenu du fichier Info.plist pour l’application MoveMe. Ce fichier identifie le nom de l’exécutable, le fichier de l’image à afficher sur l’écran d’accueil de l’utilisateur et la chaîne qui identifie de façon unique l’application dans le système. Du fait que MoveMe est une application plein écran—en d’autres termes, elle n’affiche pas la barre d’état—elle comprend aussi la clé UIStatusBarHidden et lui assigne la valeur true. Le réglage de cette clé à true permet au système de savoir qu’il ne doit pas afficher la barre d’état au lancement de l’application ou lorsque celle-ci est en cours d’exécution. Bien que l’application pourrait configurer ce même comportement programmatiquement, il ne prendrait effet qu’après le lancement de l’application, ce qui pourrait paraître étrange.

Listing 9  Le contenu du fichier Info.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>CFBundleDevelopmentRegion</key>
    <string>en</string>
    <key>CFBundleDisplayName</key>
    <string>${PRODUCT_NAME}</string>
    <key>CFBundleExecutable</key>
    <string>${EXECUTABLE_NAME}</string>
    <key>CFBundleIconFile</key>
    <string>Icon.png</string>
    <key>CFBundleIdentifier</key>
    <string>com.yourcompany.${PRODUCT_NAME:identifier}</string>
    <key>CFBundleInfoDictionaryVersion</key>
    <string>6.0</string>
    <key>CFBundleName</key>
    <string>${PRODUCT_NAME}</string>
    <key>CFBundlePackageType</key>
    <string>APPL</string>
    <key>CFBundleSignature</key>
    <string>????</string>
    <key>CFBundleVersion</key>
    <string>2.6</string>
    <key>UIStatusBarHidden</key>
    <true/>
    <key>LSRequiresIPhoneOS</key>
    <true/>
    <key>NSMainNibFile</key>
    <string>MainWindow</string>
</dict>
</plist>

Pour plus d’informations sur la configuration du fichier Info.plist de votre application, se reporter à “The Information Property List” dans iPhone Application Programming Guide.

Avec cette dernière pièce en place, vous avez maintenant toutes les informations de base nécessaires pour créer votre propre application iPhone pleinement fonctionnelle. La prochaine étape consiste à étendre le connaissance que vous venez d’acquérir dans cet article de façon à en savoir plus sur les fonctionnalités d’iPhone OS. Les applications que vous créerez devront tirer profit des fonctionnalités intégrées d’iPhone OS afin de prodiguer aux utilisateurs quelque chose d’agréable et d’intuitif. Certaines de ces fonctionnalités sont décrites dans Emmener votre Application plus loin, mais pour une liste complète de ces fonctionnalités, et sur la façon de les utiliser, se reporter à iPhone Application Programming Guide.

Emmener votre Application plus loin

Il existe de nombreuses caractéristiques associées à l’iPhone et iPod touch que les utilisateurs tiennent pour acquis. Certaines de ces caractéristiques sont en rapport avec le matériel, comme le réglage automatique de la vue en fonction de l’orientation de l’appareil. D’autres sont en rapport avec le logiciel, telles que le fait que toutes les applications iPhone partagent toute la même liste de contacts. Parce que bon nombre des caractéristiques décrites ci-après font partie intégrante de l’expérience utilisateur de base, vous devrez les examiner lors de votre phase de conception initiale de façon à étudier comment elles pourraient s’intégrer à votre application.

Détecter l’orientation et les mouvements en utilisant l’accéléromètre

L’accéléromètre de l’iPhone et de l’iPod touch apporte des données intéressantes pour le système et pour vos propres applications. Un accéléromètre mesure les variations de vitesse de façon linéaire sur un axe qui lui est propre. L’iPhone et l’iPod touch ont tous les deux trois accéléromètres qui mesurent les variations intervenant sur les trois axes d’un espace tridimensionnel, vous permettant ainsi de détecter les mouvements dans chacune de ces directions.

Figure 5  Axes des Accéléromètres

Même si vous n’aviez pas envisagé de mesurer les changements d’accélération, il y a en réalité beaucoup de choses que vous pouvez faire avec ces informations. La force de la gravité essaie toujours d’attirer des objets vers le sol. Cette force se traduit par une quantité d’accélération mesurable en direction du sol, même lorsque l’appareil est au repos. En suivant quels accéléromètres enregistrent cette accélération et en suivant l’ampleur de l’accélération, vous pouvez détecter l’orientation physique de l’appareil dans un espace 3D avec une bonne précision. Vous pouvez ensuite envoyer cette orientation sous forme de données à votre application.

Le système utilise les accéléromètres pour piloter l’orientation en cours de l’appareil et pour informer votre application que l’orientation à changé. Si l’interface de votre application peut être affichée à la fois en mode paysage et en mode portrait, vous devrez intégrer des contrôleurs de vue dans votre conception de départ. La classe UIViewController fournit l’infrastructure nécessaire pour faire pivoter votre interface, et ajuster automatiquement la position des vues en fonction des changements d’orientation.

Si vous souhaitez accéder directement aux données brutes des accéléromètres, vous pouvez le faire en utilisant l’objet partagé UIAccelerometer de l’UIKit. L’objet UIAccelerometer donne les valeurs en cours des accéléromètres à un intervalle de temps configurable. Vous pouvez également utiliser ces données afin de détecter l’orientation de l’appareil ou d’autres types de mouvement, tels qu’une secousse appliqué par l’utilisateur à l’appareil. Vous pouvez ensuite utiliser cette information pour la communiquer à un jeu ou tout autre application. Pour voir des exemples sur la façon de configurer l’objet UIAccelerometer et de recevoir des événements provenant d’un accéléromètre, voir “Accessing Accelerometer Events” dans iPhone Application Programming Guide.

Accès aux contacts utilisateur

La liste de contacts de l’utilisateur est une ressource importante que toutes les applications du système partagent. Les applications Phone, Mail et SMS Text l’utilisent pour identifier la personne que l’utilisateur souhaite contacter et pour ainsi faciliter ces actions basiques que sont les appels téléphoniques, les envois d’emails ou de SMS. Vos applications peuvent accéder à cette liste de contacts à des fins similaires ou pour obtenir d’autres informations pertinentes.

Figure 6  Accès aux contacts utilisateur

iPhone OS permet à la fois un accès direct aux contacts de l’utilisateur et un accès indirect via un ensemble d’interfaces standard. En utilisant l’accès direct, vous pouvez obtenir des informations directement à partir de la base de données de contacts. Vous pouvez utiliser ces informations au cas où vous souhaiteriez présenter ces données d’une manière différente ou les filtrer en fonction de critères spécifiques à l’application. Si vous n’avez pas besoin d’interface personnalisée, iPhone OS fournit également un ensemble d’interfaces système standard qui permettent la recherche et la création de contacts. L’intégration de ces interfaces dans votre application exige peu d’effort mais donne l’impression que votre application fait partie du système.

Vous accédez aux informations de contacts en utilisant le Carnet d’Adresses et les frameworks Address Book UI. Pour plus d’informations sur ces frameworks, se reporter à Address Book Framework Reference et Address Book UI Framework Reference.

Déterminer la position actuelle de l’utilisateur

Les appareils qui fonctionnent sous iPhone OS sont destinés aux utilisateurs mobiles. Par conséquent, les logiciels que vous écrivez pour ces appareils doivent aussi tenir compte de ce fait. Et parce que l’Internet et le Web permettent de faire des affaires n’importe où, être capable d’adapter l’information délivrée à l’utilisateur en fonction de son emplacement actuel peut être très intéressant pour l’utilisateur. Après tout, pourquoi lister les cafés de New York pour quelqu’un qui a soif à Los Angeles ? C’est ici que le framework Core Location peut vous aider.

Le framework Core Location surveille les signaux provenant des antennes de téléphone cellulaire et des hotspots Wi-Fi afin de déterminer par triangulation la position actuelle de l’utilisateur. Vous pouvez utiliser ce framework pour obtenir un emplacement initial, ou pour être averti à chaque fois que l’utilisateur change d’emplacement. Avec ces informations, vous pouvez filtrer les données que votre application délivrent ou les utiliser de façons différentes.

Pour des exemples d’utilisation, se reporter à “Getting the User’s Current Location” dans iPhone Application Programming Guide.

Jouer de l’Audio et de la Vidéo

iPhone OS comporte des fonctions audio par le biais des frameworks Core Audio et OpenAL, et permet la lecture vidéo à l’aide du framework Media Player. Core Audio apporte une interface avancée pour la lecture, l’enregistrement et la manipulation du son et de l’analyse de streaming audio. Vous pouvez l’utiliser pour la lecture simple d’effets sonores, de sons multicanaux ou de sons mixés et les positionner dans un champ audio, et même déclencher la fonction de vibration d’un iPhone. Si vous êtes un développeur de jeu et avez déjà du code qui s’appuie sur OpenAL, vous pouvez utiliser votre code dans iPhone OS pour positionner et lire de l’audio dans vos jeux.

Media Player est le framework que vous utiliserez pour la lecture de vidéos en mode plein écran. Ce framework prend en charge la lecture de nombreux formats standard de fichiers vidéo et vous permet de contrôler l’environnement de lecture, y compris l’affichage des boutons de contrôle et la façon de configurer le format d’affichage du contenu vidéo. Les développeurs de jeux peuvent utiliser ce framework pour jouer des scènes ou d’autres contenus pré-rendus, ainsi que les applications vidéo qui s’en serviront pour la lecture de films.

Figure 7  Lecture de vidéos

Pour plus d’informations sur les technologies média de iPhone OS, voir “Multimedia Support” dans iPhone Application Programming Guide.

Prise de clichés avec l’appareil photo intégré

L’application Camera de l’iPhone permet aux utilisateurs de prendre des clichés et de les stocker dans une bibliothèque centrale de photos, aux côtés des autres images qu’ils ont chargées à partir de leur ordinateur. Et bien que l’iPod Touch n’ait aucun appareil photo, il comporte aussi une bibliothèque pour stocker les images chargées. iPhone OS donne accès à ces deux fonctions via la classe UIImagePickerController du framework UIKit.

Figure 8  L’appareil photo

La classe UIImagePickerController prodigue la façon d’implémenter à la fois l’appareil photo et l’interface vers la bibliothèque de photos dans votre application. Ceux sont les interfaces système standard utilisées par d’autres applications, dont Camera et Photos. Lorsque vous affichez l’interface de sélection, le contrôleur de sélection se charge de toutes les interactions possibles et renvoie l’image sélectionnée à votre application.

Pour plus d’informations sur la manière d’utiliser les interfaces de sélection, voir “Taking Pictures with the Camera” et “Picking a Photo from the Photo Library” dans iPhone Application Programming Guide.

Texte original en anglais sur Creating an iPhone Application.

Thierry Développer pour l'iPhone iPhone, iPod