PROGRAMMER SUR IPOD, IPHONE, IPAD, ET POURQUOI PAS SUR MACOSX
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Programmer sur iPod, iPhone, iPad,
et pourquoi pas sur MacOsX…
Se procurer l’IDE Xcode_________________________________________________________________________________________ 2
Inscription auprès de « l’IOS Dev Center » __________________________________________________________________ 2
Configuration du périphérique pour le développement, « iOS Provisionning Portal » ____________ 2
Cocoa, Cocoa Touch et le concept « MVC » __________________________________________________________________ 5
Les documents à consulter pour bien commencer… ______________________________________________________ 6
Les bases de l’Objective-C ______________________________________________________________________________________ 7
Créer une classe :__________________________________________________________________________________________________ 7
Définir un attribut de type bouton et un attribut de type label accessibles par propriétés : _________ 8
Les protocoles _____________________________________________________________________________________________________ 9
La gestion de la mémoire _____________________________________________________________________________________ 11
Gestion « manuelle » de la mémoire ___________________________________________________________________________ 11
Le comptage des références ____________________________________________________________________________________ 11
Auto-libération des références ________________________________________________________________________________ 12
Gestion « automatique avec ARC » de la mémoire____________________________________________________________ 12
La conversion d’un projet non ARC vers ARC ________________________________________________________________ 13
Accès aux données, le KVC « Key Value Coding » _________________________________________________________ 13
Surveiller les données, le KVO « Key Value Observing »_________________________________________________ 14
Les différentes options d’observation : _______________________________________________________________________ 15
Les différentes clés du dictionnaire passé « change » : ____________________________________________________ 15
La prise en compte des « rares » exceptions _________________________________________________________________ 16
La liste des contrôles IBuilder disponibles ________________________________________________________________ 20
Les règles du développement : Xcode et Objective C
Règle numéro 1, pour développer sur iPod, iPhone ou iPad (que je noterai à partir de maintenant iPx) il faut
un mac avec au minimum l’OS MacOsX 10.6.2. Cette règle peut cependant être contrariée illégalement en
faisant tourner MacOsX dans une machine virtuelle.
Règle numéro 2, l’outil de développement d’Apple pour développer sur iPx ou sur MacOSx est Xcode, nous
verrons plus loin comment se le procurer.
Règle numéro 3, nul besoin d’un périphérique iPx pour développer, Xcode fournit un émulateur pour ses
périphériques iPx avec émulation de l’ensemble de ses versions d’IOS.
Règle numéro 4, si vous voulez développer sur un périphérique iPx, il faut passer par une inscription
auprès du centre de développement Apple ou « Apple Developer Center »1. Plusieurs programmes
d’inscription sont disponibles, nous les détaillerons au paragraphe « Inscription auprès de l’IOS Dev Center ».
Règle numéro 5, la programmation sur iPx utilise prioritairement le langage de programmation Objective-C,
si celui-ci ne vous est pas familier il faudra commencer par s’y intéresser avant d’envisager le codage sur iPx.
1 http://developer.apple.com
Programmer sur iPx Page 1
Auteur : Michel MARIE
Se procurer l’IDE Xcode
Xcode est fourni avec le DVD d’installation de MacOSx, DVD livré avec l’achat d’un ordinateur Mac, si
toutefois on ne dispose pas du DVD ou même du Mac il reste les solutions suivantes :
Acquérir Xcode sur l’Apple Store (gratuit si vous disposez de MacOSx Lion),
S’inscrire à un programme de développement Apple comme présenté au paragraphe suivant.
Inscription auprès de « l’IOS Dev Center »
Pour développer sur un périphérique iPx, il faut passer par une inscription dans l’un des 3 programmes de
développement disponibles auprès du centre de développement Apple, ces 3 programmes sont :
Le programme pour les centres de formation ou « Developer University Program ». Ce programme
gratuit permet aux établissements d’enseignement supérieur en informatique et après une
procédure de validation de :
o transférer et tester ses applications sur périphérique iPx,
o télécharger gratuitement les ressources de développement dont Xcode,
o créer des équipes de développement constituées d’étudiants auxquels vous attribuez des
droits spécifiques, (téléchargements des ressources, tests des applications, inscriptions des
matériels, création des profils de provisionnement).
Par contre ce programme ne permet en aucun cas de publier ses applications mêmes gratuites via
l’Apple Store, elle ne permet pas non plus d’installer définitivement ses applications sur ses propres
périphériques, l’installation est limitée via un certificat associé à un profil d’approvisionnement qui
doit être renouvelé périodiquement (durée de validité de 3 mois au moment de la rédaction de ce
document).
Le programme standard ou « iOS Developer Program Standard ». Ce programme est facturé
99$/an, il permet dans la limite de 100 applications par an de :
o transférer et tester ses applications sur périphérique iPx,
o télécharger les ressources de développement dont Xcode,
o publier gratuitement ou nom ses application via l’Apple Store.
Le programme entreprise ou « iOS Enterprise Program ». Ce programme est facturé 299$/an, il
permet pour les entreprises de :
o transférer et tester ses applications sur périphérique iPx,
o télécharger les ressources de développement dont Xcode,
o installer ses applications d’entreprise sur ses périphériques dans la limite de 500 postes sans
avoir à passer par l’Apple Store,
o disposer du support technique des ingénieurs d’Apple.
Configuration du périphérique pour le développement, « iOS Provisionning
Portal »
Une fois l’inscription à un programme de développement réalisée, le logiciel Xcode installé sur le Mac de
développement (ou dans une machine virtuelle MacOSX), et le périphérique iPx connecté sur le poste de
développement il faut encore configurer l’association « poste de développement - périphérique iPx –
application à développer ».
Cette configuration ou opération de « provisionnement » est décrite sur le portail de provisionnement de
l’iOS ou « iOS Provisionning Portal »
Programmer sur iPx Page 2
Auteur : Michel MARIE
Elle consiste a :
Générer un certificat identifiant le développeur signé par l’autorité de certification Apple et
contenant la clé privée du développeur, ce certificat servant lui même à constituer en partie les
profils d’approvisionnement qui permettront d’installer des applications sur le périphérique ou sur
l’Apple Store.
Enregistrer son ou ses matériels iPx sur le site de « provisioning »,
Générer un profil d’approvisionnement, ce profil doit être associé à :
o un développeur identifié par son certificat de développement,
o un ou plusieurs périphériques qui doivent-être préalablement enregistrés sur le portail de
provisionnement,
o un identificateur d’application (iOS Application ID) qui est généralement formé à partir de
votre nom de domaine Internet en suivant l’ordre de recherche DNS :
L’identificateur peut être générique afin d’identifier plusieurs applications, il sera
alors terminé par .*,
exemple : fr.institut-lemonnier.iris.*
S’il est unique il se terminera par le nom de l’application,
exemple : fr.institut-lemonnier.iris.appliWelcome1
Une fois ces éléments générés et installés il devient enfin possible de déployer et tester ses applications sur
les périphériques iPx. Les certificats de développement doivent être installés sur les postes de
développement alors que les profils d’approvisionnement sont installés sur les périphériques.
Programmer sur iPx Page 3
Auteur : Michel MARIE
Le schéma suivant repris depuis la documentation iOS illustre les relations entre ces différents éléments. Le trousseau permet de visualiser le certificat « développeur » et sa clé privée : Une fois tous ces éléments générés, l’outil Organizer intégré à Xcode facilite la gestion des certificats et applications associées aux profils d’approvisionnement. Programmer sur iPx Page 4 Auteur : Michel MARIE
La sélection du « device » permet ensuite de cliquer sur le bouton « Add to Portal », l’outil « Organiser »
vous demande alors de vous authentifier avec vos identifiants « Apple Developper » afin de se connecter
sur l’iOS Provisioning Portal et de télécharger dans votre « device » les profils de provisionnement qui lui
sont associés.
Cocoa, Cocoa Touch et le concept « MVC »
Cocoa est l’ensemble des frameworks écrits en Objective-C sur lesquels s’appuie Xcode pour
développer les applications MacOSX. Il comprend les frameworks Foundation, AppKit et CoreData.
Cocoa est dérivé des environnements de développement NeXTSTEP et OPENSTEP créés par NeXT à la fin
des années 1980 et acquis par Apple en 1996. On retrouve ces origines dans le nom des objets du
Framework qui commencent souvent par le préfixe NS (NSObject, NSString, NSArray, etc…).
Le framework Foundation comprend les objets non graphiques, principalement les objets qui servent à
représenter les données.
Le framework AppKit comprend les objets graphiques, tout ce qui permet d’interagir avec l’interface
utilisateur.
Le framework Core Data comprend les objets permettant la gestion de la persistance des applications.
Cocoa Touch est simplement la version de Cocoa adaptée au développement sur les périphériques à écran
tactile d’Apple, les iPx.
Et le concept « MVC » alors…
Le terme “MVC” est un sigle qui signifie « Model-View-Controller ». C'est un design pattern (patron de
conception), c'est à dire un concept d'architecture logicielle pour son application.
Le principe de base du MVC consiste à séparer les données (le “modèle”) de leur représentation (leur
affichage dans une “vue”).
Le modèle
Le “Modèle” est la représentation interne des données. Il permet comme son nom l'indique de
modéliser les données que l'on va manipuler dans l'application. Le modèle représente les véritables données
avec toutes les informations qu'elles véhiculent.
Programmer sur iPx Page 5
Auteur : Michel MARIE
La vue
La “Vue” quant à elle est la représentation visuelle de ces données à l'écran. Un même modèle peut
avoir plusieurs modes de représentation dans différentes vues (listes, tableaux, etc…).
La Vue et le Modèle sont sensés être relativement indépendants, en particulier ils ne doivent pas
forcément avoir à connaître comment sont organisées ou codées chacune des parties, de sorte qu'un modèle
puisse utiliser plusieurs vues indépendantes et qu'une vue puisse être réutilisée dans un autre projet pour
représenter des données similaires mais utilisant un modèle différent.
Le contrôleur
Le contrôleur enfin, sert à faire l'interface entre le modèle et la vue. Le contrôleur connaît à la fois le
modèle et la vue, quand la vue a besoin d'afficher un élément, elle demande au contrôleur de fournir telle
information sur tel élément. Le contrôleur sait comment demander cela au modèle, car il sait comment le
modèle est organisé, et donc sait aller chercher l'information, l'extraire, éventuellement la formater, puis la
remonter à la vue.
L'avantage de ce principe est que les modèles et les vues sont réutilisables et interchangeables. Si l'on
veut rajouter une autre représentation pour un même modèle c’est le contrôleur qui servira d'adaptateur
entre les deux.
Sous iOS, la classe UIViewController est largement utilisée pour servir de contrôleur. Un
UIViewController dispose entre autres d’une propriété « view » qui pointe sur la vue contrôlée, libre
ensuite au développeur de rajouter ce qu'il faut pour récupérer son modèle de données et le présenter à la
vue quand cette dernière demande des informations à afficher.
Les documents à consulter pour bien commencer…
Apple met à la disposition des développeurs une grande quantité de guides sur son site « App
Developper Center ». Vous trouverez ci-dessous les guides qui me paraissent indispensables à lire pour
bien débuter un développement iPx.
Pour l’apprentissage du minimum nécessaire en Objective-C :
Object-Oriented Programming with Objective-C 2
Learning Objective-C : A Primer 3
The Objective-C Programming Language 4
2http://developer.apple.com/library/mac/#documentation/cocoa/conceptual/OOP_ObjC/Introduction/Introduction.html
3http://developer.apple.com/library/mac/#referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/_index.html
4http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html%23
//apple_ref/doc/uid/TP30001163
Programmer sur iPx Page 6
Auteur : Michel MARIE
Pour la gestion de la mémoire :
Memory Management Programming Guide 5
Si vous souhaitez diffuser vos applications via l’Apple Store elles devront au préalable être validées par
les équipes de test d’Apple qui semblent être particulièrement regardantes sur la gestion de la mémoire et
ne tolèrent pas les « fuites ». Pour vous aider à cette fin, la lecture du guide précédent et l’outil « Profile »
intégré à Xcode seront de bons alliés même si depuis la sortie de l’iOS5 le ramasse-miettes et l’ARC ont été
intégrés.
Pour le développement avec Cocoa Touch:
Cocoa Fundamentals Guide 6
Apple Human Interface Guidelines 7
Les bases de l’Objective-C
Créer une classe :
Tout comme en C++ le codage d’une classe met en œuvre deux fichiers :
le fichier d’en-tête, header ou interface (.h), utilisé pour définir attributs, méthodes et propriétés de
la classe,
le fichier d’implémentation (.m), utilisé pour écrire le code des méthodes et des propriétés.
Fichier d’en-tête :
@interface MaClasse : NSObject
{
// vous placez ici vos attributs
}
// et vous définissez vos propriétés et méthodes en dehors des
// accolades
@end
5http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/MemoryMgmt/MemoryMgmt.html
6http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CocoaFundamentals/Introduction/Introduction.ht
ml%23//apple_ref/doc/uid/TP40002974
7http://developer.apple.com/library/mac/#documentation/UserExperience/Conceptual/AppleHIGuidelines/XHIGIntro/XHIGIntro.
html
Programmer sur iPx Page 7
Auteur : Michel MARIE
Fichier d’implémentation :
// Importation de votre fichier .h
#import ”MaClasse.h”;
@implementation MaClasse
// vous placez ici votre codage de MaClasse
@end
Définir un attribut de type bouton et un attribut de type label accessibles
par propriétés :
Fichier d’en-tête :
@interface classeWindowIPad: NSObject
{
IBOutlet UIButton* boutonWelcome;
IBOutlet UILabel* labelWelcome;
}
@property (nonatomic,retain) IBOutlet UIButton* boutonWelcome;
@property (nonatomic,retain) IBOutlet UILabel* labelWelcome;
@end
Le type IBOutlet signale qu’il s’agit d’un contrôle graphique produit par l’outil « Interface Builder ».
La directive @property signale que le contrôle est rendu accessible par une propriété, s’en suit des
directives entre parenthèses :
nonatomic : l’attribut n’est pas protégé contre les accès multiples,
retain : la gestion de la durée de vie de l’attribut se fait par le mode comptage de références (que
nous présenterons au paragraphe gestion de la mémoire).
Fichier d’implémentation :
#import ”classeWindowIpad.h”;
@implementation classeWindowIPad
@synthesize boutonWelcome;
@synthesize labelWelcome;
- (IBAction)clickBoutonBienvenue:(id)sender {
[self.labelWelcome setText:@"Bienvenue sur iPad"];
}
@end
La directive @synthetise auto-génère les propriétés get et set de la propriété.
La méthode signée (IBAction) est associée à un événement « action » sur un contrôle graphique.
Le paramètre sender contiendra la référence de l’objet à l’origine de l’événement. Le type (id) est un type
générique utilisé quand on ne connaît pas le type de l’objet (équivalent au void* du c++).
Le signe « - » devant la méthode signale qu’il s’agit d’une méthode d’instance, une méthode de classe est
marquée « + ». Objective-C n’implémente pas les attributs de classe, tous les attributs sont d’instance.
Par défaut les propriétés et méthodes sont protected, sinon il faut leur ajouter la directive @public,
@private ou @package.
Programmer sur iPx Page 8
Auteur : Michel MARIE
Si l’on désire coder ses propres accesseurs pour une propriété donnée on remplace alors la directive
@synthesize par @dynamic. Les propriétés devront alors avoir les signatures suivantes :
@dynamic labelWelcome;
- (id)labelWelcome {
// Code du « getter »
Return …;
}
- (void)setLabelWelcome : (id)newlabel {
// Code du « setter »
}
Il est possible de contrarier les noms par défaut des « setter » et « getter » lors de la définition de la
propriété comme dans l’exemple ci-dessous :
@property (nonatomic,retain,getter=getMonLabel,setter=setMonLabel:)
IBOutlet UILabel* labelWelcome;
Les protocoles
Les protocoles des frameworks Cocoa sont assez proches des classes d’interface qui se sont
généralisées dans le Framework.Net de Microsoft.
Un protocole décrit un ensemble de méthodes, obligatoires « @required » ou optionnelles « @optional »
qu’une classe doit implémenter si elle désire pouvoir bénéficier de ce protocole. La classe qui répondra à ce
protocole pourra donc recevoir les messages associés à ce protocole et en tirer profit.
La syntaxe pour l’adoption d’un protocole :
@interface classe : superclasse < protocole1, protocole2 >
{
}
@end
Exemple, l’adoption du protocole UITextFieldDelegate :
Ce protocole définit les messages associés à un objet graphique UITextField, tels que :
le début de l’édition,
l’effacement du texte,
le remplacement d’une partie du texte…
Toutes les méthodes de ce protocole sont optionnelles, elles sont définies par des délégués (contrat de
signature de méthode associée à un événement), ci-dessous la liste des délégués du protocole
UITextFieldDelegate tirée de la documentation Cocoa :
Overview
The UITextFieldDelegate protocol defines the messages sent to a text field delegate as part of the
sequence of editing its text. All of the methods of this protocol are optional.
Tasks
Managing Editing
– textFieldShouldBeginEditing:
– textFieldDidBeginEditing:
– textFieldShouldEndEditing:
– textFieldDidEndEditing:
Programmer sur iPx Page 9
Auteur : Michel MARIE
Editing the Text Field’s Text
– textField:shouldChangeCharactersInRange:replacementString:
– textFieldShouldClear:
– textFieldShouldReturn:
Exemple d’adoption de ce protocole pour détecter le début d’édition d’un objet UITextField :
Fichier d’en-tête du contrôleur de vue :
@interface monControleurDeVue: NSObject < UITextFieldDelegate >
{
IBOutlet UITextField* texteNom;
IBOutlet UITextField* textePrenom;
}
@property (nonatomic,retain) IBOutlet UITextField * texteNom;
@property (nonatomic,retain) IBOutlet UITextField * textePrenom;
@end
Fichier d’implémentation du contrôleur de vue :
#import ”monControleurDeVue.h”;
@implementation monControleurDeVue
@synthesize texteNom;
@synthesize textePrenom;
#pragma Code d’implémentation des délégués du protocole
- (void)textFieldDidBeginEditing:(UITextField*)textField
{
…
}
#pragma
@end
Programmer sur iPx Page 10
Auteur : Michel MARIELa gestion de la mémoire
Contrairement à Cocoa, le framework Cocoa Touch ne disposait pas des fonctionnalités du
« Garbage Collector » avant la sortie de l’iOS 5. Il est donc nécessaire de gérer la mémoire « manuellement »
lors du développement d’applications susceptibles d’être installées sur les versions d’iOS antérieures.
Depuis la version 4.2 de XCode il est demandé lors de la création d’un projet pour iPx si ARC
« Automatic Reference Counting » doit être ou non utilisée, autrement dit, si vous souhaitez que la gestion
des allocations soit faite automatiquement (applications pour iOS>=5) ou si vous souhaitez la gérer
manuellement et rendre votre application compatible avec les version iOSAuto-libération des références
Si un objet objPapa crée une instance objFiston pour le compte d’un autre objet objMaman et qu’il
ne souhaite pas le « retenir » il est conseillé de placer cette instance en auto-libération.
Chaque application Cocoa gère un objet de type NSAutoReleasePool au sein duquel les objets
« autorelease » se trouvent inscrits. Toutes les instances inscrites sont alors détruites à la fin de
l’application.
Il est possible si la consommation d’objets autorelease est importante de créer ses propres « autorelease
pool » afin de libérer la mémoire consommée, un objet autorelease s’enregistre automatiquement sur le
dernier « autorelease pool » créé.
Exemple d’inscription d’un objet « autorelease » :
NSString* maChaine =[[[ NSString alloc] init ] autorelease ];
Le code de l’autorelease pool de l’application tel qu’il est codé dans les projets Cocoa Touch :
int main(int argc, char *argv[])
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
int retVal = UIApplicationMain(argc, argv, nil, nil);
[pool release];
return retVal;
}
Exemple de création de son propre « autorelease pool » temporaire :
NSAutoreleasePool *monPoolTemporaire = [[NSAutoreleasePool alloc]
init];
…
NSString* maChaine =[[[ NSString alloc] init ] autorelease ];
NSString* maChaine =[[[ NSString alloc] init ] autorelease ];
…
[monPoolTemporaire release];
Gestion « automatique avec ARC » de la mémoire
ARC évalue la durée de vie de vos objets et insère automatiquement les appels de méthode appropriés pour
vous à la compilation. La création des objets se fait comme auparavant, le « runtime » s’occupant de leur
libération.
Avec ARC, il n’est plus possible d’appeler explicitement au sein de vos méthodes ou de surcharger les
méthodes de gestion mémoire suivantes sans substitution :
retain
retainCount
release
autorelease
dealloc
Il est toujours possible d’implémenter la méthode dealloc pour la gestion de ressources autres que la
libération des objets…
Avec ARC il n’est plus possible d’utiliser d’objets de type NSAutoreleasePool, il faut définir ses objets gérés
par le pool « autorelease » au sein d’un bloc @autoreleasepool qui selon la documentation assure une
gestion plus efficace de ceux-ci…
@autoreleasepool {
NSString *maChaine;
maChaine = [NSString alloc];
// utilisation de maChaine
}
Programmer sur iPx Page 12
Auteur : Michel MARIEDe nouveaux mots clés ont été ajoutés pour la qualification de la durée de vie dans la déclaration des objets
qui sont :
__strong ou strong : (valeur par défaut) qui vient en remplacement du retain,
__weak ou weak : pour les objets qui ne sont pas utilisés au delà de la séquence d’instructions
contenant leur allocation,
__unsafe_unretained ou unsafe_unretained : pour les objets qui ne doivent pas être gérés par le
« ramasse-miettes »
__autoreleasing ou autoreleasing : pour les objets qui sont passés en argument par référence (id *)
et doivent être « auto-nettoyés » au return de la méthode.
La conversion d’un projet non ARC vers ARC
Depuis la version 4.2 de XCode un utilitaire de conversion permet de migrer un projet disposant
d’une gestion manuelle de la mémoire vers la gestion « ARC. Celui-ci est accessible depuis la commande du
menu Edit->Refactor->Convert to Objective-C ARC.
Accès aux données, le KVC « Key Value Coding »
Le KVC est un modèle de programmation permettant une extension de la méthode d’accès aux
attributs telle que la propriété. Les KVC permettent de faire abstraction de l’implémentation de l’accès aux
données.
Avec le modèle KVC une information (donnée) est désignée par une clé (chaîne de caractères) à
laquelle est associée une valeur. Tous les objets descendant de NSObject peuvent être rendus accessibles
par le modèle KVC. Le modèle KVC dispose entre autres de quatre méthodes pour accéder à une donnée qui
sont :
valueForKey : : qui retourne l’information associée à la clé passée en paramètre, si la
propriété de même nom que la clé existe elle est appelée et si elle n’existe pas mais qu’une
variable d’instance porte ce nom elle est retournée.
setValue :forKey : : qui écrit la valeur spécifiée dans l’objet dont la clé est passée en
paramètre.
valueForKeyPath : : variante de valueForKey en composant le chemin d’accès à la donnée
passant par plusieurs clés successives séparées par un point « . ».
setValue :forKeyPath : : variante de setValue :forKey en composant le chemin d’accès à la
donnée passant par plusieurs clés successives séparées par un point « . ».
S’il n’existe ni propriété ni variable d’instance du nom de la clé une exception est déclenchée.
Exemple d’accès via KVC :
Fichier d’en-tête d’une classe disposant d’une propriété :
@interface maClasseVue : UIView {
NSString* texte;
}
@property (nonatomic,retain) NSString * texte;
@end
Fichier d’en-tête d’une classe disposant d’une référence à la classe précédente :
@interface monControleurDeVue < UITextFieldDelegate > {
maClasseVue* vue;
}
@end
Exemple d’accès en lecture à l’instance texte depuis la classe monControleurDeVue :
NSString* s = [vue valueForKey:@"texte"];
Programmer sur iPx Page 13
Auteur : Michel MARIEExemple d’accès en écriture à l’instance texte depuis la classe monControleurDeVue :
NSString* s = [NSString initWithString:@"la chaîne à copier"];
[vue setValue:s forKey:@"texte"];
Fichier d’en-tête d’une classe disposant d’une référence à la classe monControleurDeVue :
@interface applicationClasse {
monControleurDeVue* controleur;
}
@end
Exemple d’accès en lecture à l’instance texte depuis la classe applicationClasse :
NSString* s = [controleur valueForKeyPath:@"vue.texte"];
Exemple d’accès en écriture à l’instance texte depuis la classe applicationClasse :
NSString* s = [NSString initWithString:@"la chaîne à copier"];
[self setValue:s forKeyPath:@"controleur.vue.texte"];
Surveiller les données, le KVO « Key Value Observing »
Le KVO est un modèle de programmation permettant à un objet de signaler qu’il est intéressé par les
changements d’un autre objet. Ce modèle est particulièrement utile au modèle MVC car il permettra au
contrôleur de faire le lien entre un objet de type « vue » et un objet de type « modèle » (la donnée) afin que la
vue soit prévenue par une notification lorsque la donnée change.
Le modèle KVO dispose (entre autres) des méthodes suivantes pour s’abonner aux changements d’un
objet et pour indiquer quelle méthode appeler en cas de changement :
addObserver:forKeyPath:options:context: : qui permet de s’abonner aux changements
d’une donnée en précisant sa KVC, des options sur les informations à passer lors de la
notification et un contexte correspondant à un éventuel objet à passer lors de la notification,
removeObserver:forKeyPath: : qui supprime l’abonnement,
observeValueForKeyPath:ofObject:change:context: : notification transmise lorsqu’un
changement survient sur une donnée surveillée.
Exemple d’abonnement KVO :
Fichier d’en-tête d’une classe modèle :
@interface monModele {
NSString* chaine;
}
@property (nonatomic,retain) NSString * valeur;
@end
Fichier d’en-tête d’une classe vue :
@interface maVue : UIView {
UITextView* texte;
}
@property (nonatomic,retain) UITextView * texte;
@end
Programmer sur iPx Page 14
Auteur : Michel MARIEFichier d’en-tête d’une classe contrôleur :
@interface monControleur : UIViewController{
monModele* modele;
maVue* vue;
}
@end
Exemple d’abonnement aux changement du modèle depuis la classe contrôleur :
[self addObserver:vue
forKeyPath:@"modele.chaine"
options:NSKeyValueObservingOptionNew
context:NULL];
Exemple de délégué de notification implémenté dans la classe vue :
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
change:(NSDictionary *)change context:(void *)context {
if ( [keyPath isEqualToString:@"modele.chaine"])
{
texte.text = [object valueForKeyPath:@"modele.chaine"];
}
}
Les différentes options d’observation :
Le paramètre options de la méthode addObserver détermine la ou les valeurs qui seront
passées à l’observateur au travers du paramètre de type dictionnaire change de la méthode
observeValueForKeyPath.
Le paramètre options peut prendre une combinaison des valeurs suivantes :
NSKeyValueObservingOptionNew : le paramètre change contient la nouvelle valeur,
NSKeyValueObservingOptionOld : le paramètre change contient l’ancienne valeur,
NSKeyValueObservingOptionInitial : une notification est émise avant que la méthode
d’enregistrement addObserver ne rende la main.
NSKeyValueObservingOptionPrior : des notifications distinctes sont envoyées à
l'observateur avant et après chaque changement, au lieu d'une notification unique après le
changement.
Les différentes clés du dictionnaire passé « change » :
Le paramètre change de la méthode observeValueForKeyPath décrit les changements qui ont été apportés
à la valeur enregistrée pour l’observation via la méthode addObserver et selon le paramètre options.
Ci-dessous une brève et incomplète présentation des clés de ce dictionnaire, pour une information plus
complète il sera nécessaire de consulter la documentation sur le protocole NSKeyValueObserving8 :
NSKeyValueChangeKindKey : la valeur de cette clé est un objet NSNumber qui contient
une valeur égale à l’un des membres de l’énumération NSKeyValueChange indiquant quel
type de changement est survenu,
8
https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Protocols/NSKeyValueObs
erving_Protocol/Reference/Reference.html#//apple_ref/doc/constant_group/Change_Dictionary_Keys
Programmer sur iPx Page 15
Auteur : Michel MARIE NSKeyValueChangeNewKey : la valeur de cette clé est la nouvelle valeur prise pas la
variable observée (si NSKeyValueChangeKindKey = NSKeyValueChangeSetting),
NSKeyValueChangeOldKey : la valeur de cette clé est l’ancienne valeur de la variable
observée (si NSKeyValueChangeKindKey = NSKeyValueChangeSetting),
NSKeyValueChangeIndexesKey : la valeur de cette clé est un objet NSIndexSet constitué des
index des objets insérés, remplacés ou supprimés (si NSKeyValueChangeKindKey =
NSKeyValueChangeInsertion, NSKeyValueChangeRemoval, ou
NSKeyValueChangeReplacement),
NSKeyValueChangeNotificationIsPriorKey : si l’option NSKeyValueObservingOptionPrior
est spécifiée, cette notification est émise avant chaque changement de la variable observée.
Enumération NSKeyValueChange
enum {
NSKeyValueChangeSetting = 1,
NSKeyValueChangeInsertion = 2,
NSKeyValueChangeRemoval = 3,
NSKeyValueChangeReplacement = 4
}; typedef NSUInteger NSKeyValueChange;
Autre exemple du même délégué de notification avec utilisation du paramètre change :
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
change:(NSDictionary *)change context:(void *)context {
if ([keyPath isEqualToString:@"modele.chaine"]) {
NSNumber* changeType = [change
objectForKey:NSKeyValueChangeKindKey];
if([changeType intValue] == NSKeyValueChangeSetting){
id valeur = [change objectForKey: NSKeyValueChangeNewKey];
if ( [valeur isKindOfClass:[NSString class]]==YES)
texte.text = [object valueForKeyPath:@"modele.chaine"];
}}}
La prise en compte des « rares » exceptions
Traitement “classique” des exceptions.
@try
{
// Code à risque
}
@catch (NSException * e)
{
NSLog(@"Exception: %@", e);
// Affichage de l’exception dans une “alert View”
UIAlertView* alertView = [[UIAlertView alloc]
initWithTitle:@”Exception” message:e.description
delegate:self cancelButtonTitle:@"OK"
otherButtonTitles:nil];
// ou delegation de l’exception
@throw exception;
}
@finally {
// Passage obligé
}
Programmer sur iPx Page 16
Auteur : Michel MARIEBrève présentation de l’outil de développement XCode 4.2.1
La figure suivante donne une vue d’ensemble de l’environnement XCode suite à la création d’un
projet du type « Single View Application » sans les options « Use Storyboard » et « use ARC ».
L’outil organizer pour la
gestion du « provisionnement »
L’organisation des vues
du périphérique
dans la fenêtre
Choix du périphérique
Ajout d’une bibliothèque
Framework
Les fichiers sources Les ressources à La bibliothèques des
A compiler incorporer au dossier objets graphiques pour
de l’application la création de la vue
(bundle) avec IBuilder
Les différents fichiers du projet « Single View Application » font apparaître :
Une classe AppDelegate, classe principale de l’application en charge des événements tels
que le chargement, changement d’état (actif, inactif, arrière-plan, etc…) de l’application.
Une vue générée par IBuilder, fichier ViewController.xib et décrite en XML.
Une classe ViewController, classe contrôleur de la vue précédente.
Une fonction principale main, point d’entrée de l’application.
Un fichier d’extension .pList, fichier XML de configuration de l’application.
Un fichier d’extension .pch fichier « prefix header » ou fichier d’en-tête précompilé ».
Programmer sur iPx Page 17
Auteur : Michel MARIELa figure suivante donne une autre vue d’ensemble de l’environnement XCode permettant le choix de
la cible de déploiement, de l’icône de l’application, des orientations prises en compte et des fonds d’écran de
démarrage :
iOS du matériel Icône de Images de fond (format PNG) affichées
cible pour le l’application ajoutée pendant la phase de démarrage de
déploiement au bundle (format l’application.
PNG 72x72pixels) Pour l’ipad le fond d’écran doit avoir une
résolution de 1024x768 pixels en mode
Sélection des orientations du paysage et de 768x1004 pixels en mode
matériel prise en compte par portrait.
l’application pour l’auto-rotation
des vues
La figure suivante montre le fichier source de la classe principale (singleton) de l’application avec
quelques-unes des méthodes du protocole UIApplicationDelegate.
Cette classe dispose des attributs suivants :
window, fenêtre de l’application ayant pour rôle de charger les différentes vues de votre
application et de basculer entre ces vues,
viewController, instance du contrôleur principal de cette application.
Programmer sur iPx Page 18
Auteur : Michel MARIECette classe dispose des méthodes suivantes :
didFinishLauchingWithOptions : appelée à la fin du chargement de l’application, le paramètre
lauchOptions permet de connaître la raison du chargement de l’application (ouverture via une
interaction avec un document associé à votre application, via une notification locale ou distante,
etc…). Elle est ici utilisée pour :
créer l’objet fenêtre de l’application,
charger la vue dans cette fenêtre,
associer le contrôleur de vue principal de l’application,
et enfin rendre la fenêtre avec sa vue visible.
applicationWillResignActive : appelée pour signaler que l’application va passer dans l’état inactif
(lorsque certaines interruptions sont traitées par le système comme la réception d’un appel ou d’un
SMS). Une application dans l’état inactif continue à fonctionner mais ne prend plus en compte les
événements.
applicationDidEnterBackground : appelée à la place de la méthode applicationWillTerminate
lorsque l’application supporte l’exécution en arrière-plan pour signaler le fait qu’elle vient de
passer en mode « background ».
applicationWillEnterForeground : appelée pour signaler le passage de l’application du mode
« background » au mode inactif, passage obligé avant d’atteindre le mode actif. L’appel de cette
méthode est donc invariablement suivi de l’appel de la méthode applicationDidBecomeActive qui
signale le passage de l’état inactif à l’état actif.
applicationWillTerminate : appelée pour signaler que l’application va se terminer et être
supprimée de la mémoire. Elle sera utilisée pour effectuer le « nettoyage final » des ressources de
l’application. Le système accorde 5 secondes à votre application pour traiter cette méthode, délai
au-delà duquel il détruira celle-ci sans autre signalement.
Programmer sur iPx Page 19
Auteur : Michel MARIELa figure suivante montre la vue de l’application construite par IBuilder dans un fichier
d’extension « .xib ». C’est depuis cette vue que l’on construit sa vue à partir de « glisser-déposer »
des objets graphiques dans la vue et que l’on paramètre ces objets.
First Responder : représente le premier File’s Owner : représente l’instance du
view : représente objet dans la chaîne des « Responder ». contrôleur de vue en charge de la vue courante
l’instance view, Les messages sont reçus en premier par (fichier XIB).
objet de la vue cet objet. Il permet d’associer les actions Il permet d’associer les éléments de la vue aux
courante. dans la vue aux méthodes de traitement attributs du contrôleur par (CTRL + Glisser-
(IBAction) par (CTRL + Glisser-Déposer) Déposer)
Enfin, la figure suivante fait apparaître les associations installées entre les contrôles
IBuilder de la vue et les attributs liés de la classe contrôleur de vue.
Le contrôle Button est associé à Le contrôleur de vue gère une action
l’attribut monButton, etc… de la vue via la méthode (IBAction)
actionClickSurMonBouton
Programmer sur iPx Page 20
Auteur : Michel MARIELa liste des contrôles IBuilder disponibles
La figure suivante donne une brève description des contrôles IBuilder actuellement disponibles :
Label UILabel : Texte non modifiable par l'utilisateur
Round Rect
UIButton : Bouton de commande touch
Button
Segmented
UISegmentedControl : Onglets permettant d’afficher différentes vues/contrôles
Control
Text Field UITextField : Zone de texte modifiable par l'utilisateur
Slider UISlider : Curseur pour faciliter la saisie d'une valeur
Switch UISwitch : Bouton de type ON/OFF
Activity UIActivityIndicatorView : Indicateur d'activité pour faire patienter l'utilisateur
Indicator View pendant un long traitement
Progress View UIProgressView : Indicateur de progression utilisé pendant un long traitement
UIPageControl : Indique la page en cours de visualisation (dans une application multi-
Page Control
page)
Table View UITableView : Liste hiérarchique d'informations textuelles disposées verticalement
Table View Cell UITableViewCell : Paramètre d'une des cellules affichées dans un Table View
Image View UIImageView : Conteneur permettant d'afficher une image ou une animation
Text View UITextView : Zone de texte multi-ligne éditable
Web View UIWebView : Affichage d'un contenu Web
Map View UIMapView : Affichage d'une carte, similaire à celle affichée dans l'application Plans
UIScrollView : Contrôle permettant d'afficher un contenu d'une taille supérieure à celle
Scroll View
de la fenêtre/du contrôle en faisant glisser l'affichage dans la zone de visualisation
UIDatePicker : Sélection d'une date et d'une heure à l'aide de plusieurs contrôles en
Date Picker
forme de roues
Picker View UIPickerView : Sélection d'une valeur dans un contrôle en forme de roue
Ad BannerView ADBannerView : Vue dédiée à l'affichage de publicités
Programmer sur iPx Page 21
Auteur : Michel MARIEGLKit View GLKView : Vue OpenGL ES
Tap Gesture
UITapGestureRecognizer : Reconnaissance d'une gestuelle multitouch
Recognizer
Pinch Gesture
UIPinchGestureRecognizer : Reconnaissance de la gestuelle "rétrécir"
Recognizer
Rotation
Gesture UIRotationGestureRecognizer : Reconnaissance de la gestuelle "rotation"
Recognizer
Swipe Gesture
UISwipeGestureRecognizer : Reconnaissance de la gestuelle "glisser"
Recognizer
Pan Gesture
UIPanGestureRecognizer : Reconnaissance de la gestuelle "glisser"
Recognizer
Long Press
Gesture UILongGestureRecognizer : Reconnaissance de la gestuelle "long toucher"
Recognizer
NSObject : Template pour un objet non disponible dans Interface Builder, tiré d'une
Object
instance d'une classe
UIViewController : Contrôle dédiée à la gestion de barres d'outils, barres de navigation
View Controller
et vues d'une application
Table View
UITableViewController : Contrôle dédié à la gestion d'un Table View
Controller
UINavigationViewController : Ce contrôle est dédié à la gestion des contrôleurs de
Navigation
vue, il gère une pile de contrôleurs de vue et fournit des informations relatives à la vue
Controller
active.
Tab Bar
UITabBarController : Gère plusieurs vues au travers d'onglets
Controller
GLKit View GLKViewController : Contrôleur de vue standard avec en plus l’implémentation d’une
Controller boucle de rendu Open GL
UIView : Zone rectangulaire de tracé d’une vue et de gestion des événements pour cette
View
vue.
Navigation Bar UILabel : Barre de navigation, affichée juste en dessous de la barre d'état
Navigation Item UINavigationBar : Elément affiché dans un contrôle Navigation Bar
Search Bar UISearchBar : Barre de recherche éditable
Search Bar and
Search Display UISearchBar : Barre de recherche et son contrôleur associé
Controller
Toolbar UIToolBar : Barre d'outils contenant un ou plusieurs boutons
Programmer sur iPx Page 22
Auteur : Michel MARIEBar Button Item UIBarButtonItem : Un bouton dans un contrôle Toolbar
Fixed Space Bar
UIBarButtonItem : Espace ajustable par le programmeur dans un contrôle Toolbar
Button Item
Flexible Space UIBarButtonItem : Espace qui s'ajuste automatiquement en fonction de la place
Bar Button Item disponible dans un contrôle Toolbar
Tab Bar UITabBar : Barre d'onglets
Tab Bar Item UITabBarItem : Une icône représentant un onglet dans un contrôle Tab Bar
Programmer sur iPx Page 23
Auteur : Michel MARIEVous pouvez aussi lire
