Apple Watch en bref : une introduction aux fonctionnalités pour les développeurs iOS

Il y a eu beaucoup d'appréhension autour du SDK Apple Watch, annoncé lors de la WWDC en juin dernier et sorti tout récemment.

Ce n'est que le premier tour, avec des fonctionnalités limitées. Apple Watch v2 suivra, mais pas si tôt - les développeurs iOS avant-gardistes doivent donc être prêts à attendre quelques mois.

Le ressenti chez les développeurs est extrêmement diversifié. De nombreux développeurs iOS sont déçus par les nombreuses limitations imposées par Apple Watch SDK et ses fonctionnalités. D'un autre côté, beaucoup d'entre nous sont excités, tandis que d'autres ne sont pas trop loin d'une position neutre. Mais, après tout, tout le monde est apparemment heureux d'avoir un nouveau jouet avec lequel jouer.

Une chose qui attire l'attention, c'est la façon dont les utilisateurs d'Apple Watch sont désignés. Ce ne sont pas des utilisateurs ou des utilisateurs mobiles , ni des utilisateurs de montres ou (avec une pincée d'originalité) des observateurs . Ce sont simplement des porteurs . Un terme qui sonne un peu bizarre, car si un utilisateur utilise , ce qui implique qu'il interagit, un porteur porte , et cela ressemble à un usage passif. Bien sûr, l'Apple Watch est loin d'être un appareil passif. Il combine les fonctionnalités traditionnelles d'une montre avec des options plus avancées rendues possibles par la technologie moderne, en particulier lorsqu'il est utilisé en combinaison avec un iPhone. Il n'y a pas si longtemps, les téléphones ont commencé à devenir bien plus que de simples téléphones - l'histoire se répète.

Cependant, à la fin, le nom du porteur semble être un choix judicieux. Au moins, lorsque j'écris des histoires d'utilisateurs, je n'ai pas à spécifier "En tant qu'utilisateur d'Apple Watch, je veux ..." en entier, je peux simplement raccourcir cela en "En tant que porteur , je veux ..." - moins d'ambiguïté.

Appareil et interface utilisateur

En omettant toutes les fonctionnalités de l'Apple Watch qui ne sont pas strictement liées au développement, le problème le plus important auquel les concepteurs et les développeurs doivent faire face est la taille - en fait, il existe 2 modèles d'Apple Watch différents :

• Écran 38 mm avec une résolution de 272 x 340 px
• Écran de 42 mm avec une résolution de 312 x 390 px

avec un affichage de la rétine dans les deux cas.

Inutile de dire que c'est aux développeurs iOS de s'assurer que l'application a l'air bien sur les deux versions.

Connectivité Apple Watch

L'Apple Watch communique avec l'iPhone compagnon via Bluetooth 4.0, et elle est également compatible NFC. Apparemment, il n'a pas de connectivité WiFi. Bien qu'il puisse se connecter via l'iPhone et utiliser à la fois une connexion Wi-Fi et une connexion de données cellulaire. Mais dans une info presse Apple indique clairement qu'il dispose également du Wi-Fi 802.11b/g.

Interaction de l'utilisateur

L'interaction de l'utilisateur (ou de l'utilisateur, si vous préférez) peut se produire de 4 manières différentes :

• toucher simple : une pression sur un bouton est un exemple typique
• force touch : activé en appliquant plus de force lorsque vous appuyez et maintenez l'écran. Semblable au clic droit de la souris sur un PC, il affichera un menu contextuel (contenant jusqu'à 4 éléments)
• geste : balayage vertical pour faire défiler, balayage horizontal pour naviguer entre les pages, balayage du bord gauche pour revenir en arrière
• couronne numérique : entrée matérielle utilisée pour un défilement précis

Il existe certaines limitations concernant l'interaction de l'utilisateur, en particulier concernant les gestes :

• ils sont prédéterminés, donc les gestes personnalisés ne sont pas pris en charge
• multi touch n'est pas pris en charge, donc pas de pincement pour zoomer ou gestes similaires nécessitant plus d'un doigt

Voici l'exemple de menu contextuel du guide Apple WatchKit.

Interface utilisateur

En parlant de l'interface utilisateur Apple Watch, il existe plusieurs limitations imposées par la taille réduite de l'écran, par les choix de conception et, dans de nombreux cas, comme une conséquence naturelle du matériel sous-jacent. Nous nous attendons à ce que certains d'entre eux changent pour le mieux dans les futures versions du SDK, bien qu'il ne soit pas possible d'anticiper ni de prévoir ce qui changera réellement.

La première limitation concerne la manière dont l'interface utilisateur est implémentée : via des storyboards uniquement.

Navigation sur Apple Watch

WatchKit propose deux manières mutuellement exclusives de naviguer parmi les vues d'une application Apple Watch :

• un modèle de navigation hiérarchique, similaire à celui utilisé dans iOS, avec des vues empilées pendant la navigation
• un modèle basé sur une page plate, où l'utilisateur peut naviguer entre les pages en balayant vers la gauche et vers la droite

Malheureusement, combiner ces deux modèles de navigation dans la même application n'est pas possible. L'un d'entre eux doit être choisi et utilisé dans toute l'application.

Cependant, tout contrôleur d'interface peut présenter un contrôleur d'interface modal, qui peut être soit un contrôleur d'interface unique, soit plusieurs contrôleurs d'interface, agencés à l'aide d'un modèle de navigation de page.

Éléments de l'interface utilisateur

Il existe 11 composants d'interface distincts :

• bouton
• glissière
• image
• étiqueter
• séparateur
• glissière
• changer
• table
• date : affichage automatique de la date ou de l'heure actuelle
• timer : affichage d'un compte à rebours, mis à jour automatiquement
• groupe : un conteneur pour un ou plusieurs composants enfants
• carte : affichage d'une carte non interactive, éventuellement avec un maximum de 5 annotations

Dispositions

Le composant de groupe peut être utilisé pour combiner des éléments d'interface utilisateur Apple Watch dans une disposition verticale ou horizontale . Les éléments seront automatiquement disposés en fonction de leur taille. Un certain degré de flexibilité est disponible ici, étant donné que les groupes peuvent être imbriqués.

Malheureusement, la mise en page automatique n'est pas disponible. Mais, étant donné que l'interface utilisateur est beaucoup plus simple par rapport à l'homologue iOS, ce n'est probablement pas une grosse perte.

Pour les listes, le composant table crée et gère le contenu à l'aide d'un modèle de colonne unique, tout comme UITableView . Cependant, il n'utilise pas le modèle de délégation - la source de données est directement fournie à la table en spécifiant d'abord le nombre de lignes, puis en initialisant le contenu de chaque ligne dans une boucle for. Sur une note positive, il est toujours possible d'utiliser des lignes de tableau personnalisées (c'est-à-dire des cellules dans le jargon iOS)

Regards

Les aperçus sont des vues en lecture seule, sur une seule page et non défilables, utilisées pour afficher un instantané de données opportunes et pertinentes spécifiques à une application. Aucune interaction de l'utilisateur n'est autorisée, à l'exception de l'événement de tapotement. Appuyez sur le coup d' œil pour lancer simplement l'application, en fournissant éventuellement un contexte pour permettre à l'application d'afficher un contrôleur d'interface spécifique.

Par exemple, une application météo Apple Watch peut utiliser Glance pour afficher la température actuelle, l'emplacement, etc. En appuyant dessus, l'application s'ouvre et affiche des informations plus détaillées.

Voici l'exemple Glance du guide officiel Apple WatchKit.

Notifications Apple Watch

Il existe 2 types de notification : aperçu court et aperçu long .

La notification de regard court est utilisée pour alerter le porteur que quelque chose s'est passé, et elle est automatiquement rejetée lorsque le poignet est abaissé. La mise en page est très simple et se compose de l'icône de l'application, du nom de l'application et du titre de la notification.

Garder le poignet levé pendant un certain temps, ou appuyer explicitement sur la notification de regard court, le transformera en une notification de regard long . Ce type de notifications fournit plus de détails et prend en charge l'interaction de l'utilisateur via des boutons personnalisables. Ces boutons peuvent envoyer des notifications à l'application. Contrairement à la notification courte, l'utilisateur doit ignorer explicitement une notification longue durée en appuyant sur un bouton qui s'affiche automatiquement en bas de la vue.

Vous trouverez plus d'informations sur l'utilisation des notifications Apple Watch ici.

Développement

Architecture

En téléchargeant une version Xcode prenant en charge le WatchKit (actuellement la version bêta 6.2) et en essayant de démarrer avec un projet WatchKit sans lire aucune documentation, un développeur peut se sentir confus car il n'y a pas de modèle WatchKit :

Il n'y a pas d'application de surveillance autonome et une application de surveillance ne peut être ajoutée qu'en tant que nouvelle cible à une application iOS existante.

La raison en est l'architecture et la manière dont l'application Watch interagit avec l'application iOS associée :

Lorsque l'application est lancée sur la montre, l'extension iOS compagnon est automatiquement lancée. Ils fonctionnent tous les deux en synergie, l'application de montre affichant le contenu au porteur et répondant aux interactions, tandis que l'extension iOS fait tout le reste. En effet, aucun code applicatif n'est exécuté sur la montre : tout le traitement est délégué à l'extension iOS.

Ce modèle ressemble étroitement au modèle d'application Web navigateur <->, où la logique du domaine est exécutée côté serveur, et le côté client est responsable de l'affichage du contenu à l'utilisateur et de la réponse aux actions de l'utilisateur.

L'application Watch, qui est installée sur l'appareil, se compose du storyboard et de toutes les ressources statiques associées, regroupées dans un ensemble. Ce bundle est statique, ce qui signifie qu'il n'est pas possible d'ajouter ou de modifier des ressources, des vues, des images, etc. au moment de l'exécution.

Ce modèle client-serveur statique impose plusieurs limitations au développeur iOS qui souhaite ajouter une application Watch à son répertoire, et c'est probablement l'une des principales raisons pour lesquelles certains développeurs n'ont pas réagi positivement. Une autre remarque populaire concerne les animations : elles ne sont tout simplement pas prises en charge. La seule façon d'imiter une animation consiste à regrouper des images individuelles dans l'application Watch, puis à simuler l'animation en affichant des images dans une séquence. La bonne nouvelle est qu'en nommant les images de manière séquentielle, vous pouvez automatiser l'animation directement depuis Interface Builder, bien que la même chose puisse être faite à partir du code avec une seule invocation d'une méthode de contrôle d'image.

Cependant Apple a déjà annoncé qu'une nouvelle version sortira parfois l'année prochaine, avec un support pour les applications natives, pour lesquelles il n'y a pas encore plus de détails.

Le cadre Apple Watch : un aperçu rapide

WatchKit n'utilise pas, n'hérite pas ou ne se spécialise pas dans UIKit. Un nouveau cadre a été mis en place, spécialement conçu et optimisé pour la montre, pour son petit écran et pour le matériel limité. Le framework se compose de 15 classes seulement, dont 12 sont des composants d'interface utilisateur (étiquette, bouton, etc.).

La classe la plus importante exposée par le framework est WKInterfaceController , qui est l'homologue WatchKit de UIViewController . Donc, ce que dans iOS (et OSX) s'appelle le contrôleur de vue , dans Apple Watch est un contrôleur d'interface .

Sans creuser trop profondément, l'amélioration la plus notable par rapport à UIKit, du point de vue d'un développeur Apple, est l'établissement d'un modèle pour transmettre les données entre les contrôleurs d'interface. Un rapide coup d'oeil à l'initialiseur:

Swift init(context: AnyObject?) // context from pushing controller or nil

révèle qu'il est possible de fournir un objet arbitraire à une instance de contrôleur d'interface (appelé le context dans toutes les API), simplifiant et normalisant la transmission de données d'un contrôleur d'interface à un autre. Le seul inconvénient est que l'objet n'est pas d'un type générique, mais d'un AnyObject opaque qui doit être transtypé vers le type attendu à l'intérieur de l'initialiseur du contrôleur d'interface de destination. C'est probablement un compromis pour avoir encore (et probablement aussi vouloir) continuer à utiliser Objective C.

Le cycle de vie du contrôleur d'interface est simplifié par rapport à l'homologue du contrôleur de vue, composé de 3 transitions uniquement :

• init : invoqué lorsque l'objet est instancié
• willActivate : invoqué lorsque le contenu est sur le point d'être affiché
• didDeactivate : invoqué lorsque l'interface vient d'être masquée

En plus de montrer le contenu à l'utilisateur, le contrôleur d'interface est également responsable de :

• gérer les interactions des utilisateurs
• gérer un menu contextuel
• coordonner l'activité de transfert
• répondre à la notification

Apple WatchKit est-il prêt ?

Avec les nombreuses limitations, le kit de montre peut apparaître comme un produit immature. Et en réalité ça l'est. Il ne prend pas en charge les applications de montre natives, sans oublier qu'il n'y a pas encore de dispositif de montre sur le marché, de sorte que les développeurs ne sont toujours pas en mesure de tester leurs applications et d'avoir une idée réelle et un retour d'information sur le fonctionnement de l'application.

Ok, il y a un simulateur, qui n'est en fait pas un simulateur indépendant, mais accessible en tant qu'affichage externe au simulateur iOS (via le menu Matériel -> Affichages externes). Mais un simulateur ne remplace jamais un appareil réel - bon pendant le développement et pour le débogage, mais pas assez.

Le WatchKit n'est qu'un aperçu, une version bêta, un apéritif, qui va évoluer à chaque nouvelle version. Les développeurs iOS ont la première version, jouons avec et essayons d'en tirer le meilleur parti.