Créer une application Android facilement sans programmation cours
Table des matières
1 Introduction 7
2 Les bases indispensables à toute application 9
2.1 L’univers Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.1 La création d’Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.2 La philosophie et les avantages d’Android . . . . . . . . . . . . . . . . . . 10
2.1.3 Les difficultés du développement pour des systèmes embarqués . . . . . . . 11
2.1.4 Le langage Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.5 En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Installation et configuration des outils . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.1 Conditions initiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Le Java Development Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.3 Eclipse, l’ADT et le SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.4 L’émulateur de téléphone : Android Virtual Device . . . . . . . . . . . . . . 23
2.2.5 Test et configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.2.6 Configuration du vrai terminal . . . . . . . . . . . . . . . . . . . . . . . . 32
2.3 Votre première application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.3.1 Activité et vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.3.2 Création d’un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.3.3 Un non-Hello world! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.3.4 Lancement de l’application . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.4 Les ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.4.1 Le format XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
2.4.2 Les différents types de ressources . . . . . . . . . . . . . . . . . . . . . . 61
2.4.3 L’organisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
2.4.4 Ajouter un fichier avec Eclipse . . . . . . . . . . . . . . . . . . . . . . . . 66
2.4.5 Récupérer une ressource . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3 Création d’interfaces graphiques 77
3.1 Constitution des interfaces graphiques . . . . . . . . . . . . . . . . . . . . . . . 77
3.1.1 L’interface d’Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.1.2 Règles générales sur les vues . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.1.3 Identifier et récupérer des vues . . . . . . . . . . . . . . . . . . . . . . . 86
3.2 Les widgets les plus simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.2.1 Les widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.2.2 Gérer les évènements sur les widgets . . . . . . . . . . . . . . . . . . . . . 100
3.3 Organiser son interface avec des layouts . . . . . . . . . . . . . . . . . . . . . . 112
3.3.1 LinearLayout : placer les éléments sur une ligne . . . . . . . . . . . . . . . 112
3.3.2 RelativeLayout : placer les éléments les uns en fonction des autres . . . . . . 123
3.3.3 TableLayout : placer les éléments comme dans un tableau . . . . . . . . . . 131
3.3.4 FrameLayout : un layout un peu spécial . . . . . . . . . . . . . . . . . . . 136
Table des matières
3.3.5 ScrollView : faire défiler le contenu d’une vue . . . . . . . . . . . . . . . . 137
3.4 Les autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
3.4.1 Aspect général des fichiers de ressources . . . . . . . . . . . . . . . . . . . 138
3.4.2 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
3.4.3 Les drawables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
3.4.4 Les styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
3.4.5 Les animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
3.5 TP : un bloc-notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
3.5.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
3.5.2 Spécifications techniques . . . . . . . . . . . . . . . . . . . . . . . . . . 157
3.5.3 Déboguer des applications Android . . . . . . . . . . . . . . . . . . . . . . 161
3.5.4 Ma solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
3.5.5 Objectifs secondaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
3.6 Des widgets plus avancés et des boîtes de dialogue . . . . . . . . . . . . . . . . . 178
3.6.1 Les listes et les adaptateurs . . . . . . . . . . . . . . . . . . . . . . . . . 178
3.6.2 Plus complexe : les adaptateurs personnalisés . . . . . . . . . . . . . . . . 192
3.6.3 Les boîtes de dialogue . . . . . . . . . . . . . . .. . . . . . . . . . . . 196
3.6.4 Les autres widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
3.7 Gestion des menus de l’application . . . . . . . . . . . . . . . . . . . . . . . . . 209
3.7.1 Menu d’options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
3.7.2 Menu contextuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
3.7.3 Maintenant que vous maîtrisez les menus, oubliez tout . . .. . . . . . . 215
3.8 Création de vues personnalisées . . . . . . . . . . . . . . . . . . . . . . . . . . 216
3.8.1 Règles avancées concernant les vues . . . . . . . . . . . . . . . . . . . . . 217
3.8.2 Méthode 1 : à partir d’une vue préexistante . . . . . . . . . . . . . . . . . . 220
3.8.3 Méthode 2 : une vue composite . . . . . . . . . . . . . . . . . . . . . . . . 225
3.8.4 Méthode 3 : créer une vue en partant de zéro . . . . . . . . . . . . . . . . . 228
4 Vers des applications plus complexes 235
4.1 Préambule : quelques concepts avancés . . . . . . . . . . . . . . . . . . . . . . . 235
4.1.1 Généralités sur le nœud . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
4.1.2 Le nœud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
4.1.3 Les permissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
4.1.4 Gérer correctement le cycle des activités . . . . . . . . . . . . . . . . . . . 241
4.1.5 Gérer le changement de configuration . . . . . . . . . . . . . . . . . . . . 245
4.2 La communication entre composants . . . . . . . . . . . . . . . . . . . . . . . . 250
4.2.1 Aspect technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
4.2.2 Les intents explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
4.2.3 Les intents implicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
4.2.4 La résolution des intents . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
4.2.5 Pour aller plus loin : navigation entre des activités . . . . . . . . . . . . . . 267 4.2.6 Pour aller plus loin : diffuser des intents . . . . . . . . . . . . . . . . . . . 270
4.3 Le stockage de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
4.3.1 Préférences partagées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
4.3.2 Manipulation des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . 281
4.4 TP : un explorateur de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
4.4.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
4.4.2 Spécifications techniques . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Table des matières
4.4.3 Ma solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
4.4.4 Améliorations envisageables . . . . . . . . . . . . . . . . . . . . . . . . . 308
4.5 Les bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
4.5.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
4.5.2 Création et mise à jour . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
4.5.3 Opérations usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
4.5.4 Les curseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
5 Concepts avancés325
5.1 Le travail en arrière-plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
5.1.1 La gestion du multitâche par Android . . . . . . . . . . . . . . . . . . . . 325
5.1.2 Gérer correctement les threads simples . . . . . . . . . . . . . . . . . . . 328
5.1.3 AsyncTask . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
5.2 Les services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
5.2.1 Qu’est-ce qu’un service? . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
5.2.2 Gérer le cycle de vie d’un service . . . . . . . . . . . . . . . . . . . . . . . 344
5.2.3 Créer un service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
5.2.4 Les notifications et services de premier plan . . . . . . . . . . . . . . . . . 353
5.2.5 Pour aller plus loin : les alarmes . . . . . . . . . . . . . . . . . . . . . . . 360
5.3 Le partage de contenus entre applications . . . . . . . . . . . . . . . . . . . . . 362
5.3.1 Côté client : accéder à des fournisseurs . . . . . . . . . . . . . . . . . . . . 363
5.3.2 Créer un fournisseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
5.4 Créer un AppWidget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 5.4.1 L’interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
5.4.2 Définir les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
5.4.3 Le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
5.4.4 Déclarer l’AppWidget dans le Manifest . . . . . . . . . . . . . . . . . . . . 379
5.4.5 Application : un AppWidget pour accéder aux tutoriels du Site du Zéro . . . . 380
6 Exploiter les fonctionnalités d’Android 389
6.1 La connectivité réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
6.1.1 Surveiller le réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
6.1.2 Afficher des pages Web . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
6.1.3 Effectuer des requêtes HTTP . . . . . . . . . . . . . . . . . . . . . . . . . 391
6.2 Apprenez à dessiner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
6.2.1 La toile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
6.2.2 Afficher notre toile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
6.3 La localisation et les cartes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
6.3.1 La localisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
6.3.2 Afficher des cartes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
6.4 La téléphonie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
6.4.1 Téléphoner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
6.4.2 Envoyer et recevoir des SMS et MMS . . . . . . . . . . . . . . . . . . . . . 419
6.5 Le multimédia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.5.1 Le lecteur multimédia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.5.2 Enregistrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
6.6 Les capteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
6.6.1 Les différents capteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
6.6.2 Opérations génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Table des matières
6.6.3 Les capteurs de mouvements . . . . . . . . . . . . . . . . . . . . . . . . . 437
6.6.4 Les capteurs de position . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
6.6.5 Les capteurs environnementaux . . . . . . . . . . . . . . . . . . . . . . . 440
6.7 TP : un labyrinthe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
6.7.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
6.7.2 Spécifications techniques . . . . . . . . . . . . . . . . . . . . . . . . . . 442
6.7.3 Ma solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
6.7.4 Améliorations envisageables . . . . . . . . . . . . . . . . . . . . . . . . . 464
7 Annexes 469
7.1 Publier et rentabiliser une application . . . . . . . . . . . . . . . . . . . . . . . 469
7.1.1 Préparez votre application à une distribution . . . . . . . . . . . . . . . . . 469
7.1.2 Les moyens de distribution . . . . . . . . . . . . . . . . . . . . . . . . . . 474
7.1.3 Rentabilisez votre application . . . . . . . . . . . . . . . . . . . . . . . . 482
7.2 L’architecture d’Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
7.2.1 Le noyau Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
7.2.2 Le moteur d’exécution d’Android . . . . . . . . . . . . . . . . . . . . . . 490
8 Conclusion 493
8.1 Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
1 Introduction
Bonjour à tous et bienvenue dans le monde merveilleux du développement d’applications Android!
Figure 1.1 – Bugdroid, la mascotte d’Android
Avec l’explosion des ventes de smartphones ces dernières années, Android a pris une place importante dans la vie quotidienne. Ce système d’exploitation permet d’installer des applications de toutes sortes : jeux, bureautique, multimédia, etc. Que diriez-vous de développer vos propres applications pour Android, en les proposant au monde entier via le Play Store, le marché d’applications de Google? Eh bien figurez-vous que c’est justement le but de ce cours : vous apprendre à créer des applications pour Android!
Cependant, pour suivre ce cours, il vous faudra quelques connaissances :
— Les applications Android étant presque essentiellement codées en Java, il vous faut connaître ce langage.
— Connaître un minimum de SQL pour les requêtes. Si vous ne connaissez absolument rien en SQL, vous pourrez tout de même suivre le cours dans son intégralité, mais constituer votre propre base de données sans théorie me semble risqué.
— Et enfin, être un minimum autonome en informatique : vous devez par exemple être capables d’installer Eclipse tout seul (vous voyez, je ne vous demande pas la lune).
Rien de bien méchant, comme vous pouvez le voir. Mais le développement pour Android est déjà assez complet comme cela, ce serait bien trop long de revenir sur ces bases-là. Ce cours débutera cependant en douceur et vous présentera d’abord les bases essentielles pour le développement Android afin que vous puissiez effectuer des applications simples et compatibles avec la majorité des terminaux. Puis nous verrons tout ce que vous avez besoin de savoir afin de créer de belles interfaces graphiques; et enfin on abordera des notions plus avancées afin d’exploiter les multiples facettes que présente Android, dont les différentes bibliothèques de fonctions permettant de mettre à profit les capacités matérielles des appareils.
À la fin de ce cours, vous serez capables de réaliser des jeux, des applications de géolocalisation, un navigateur Web, des applications sociales, et j’en passe. En fait, le seul frein sera votre imagination!
1 Introduction
->
Figure 1.2 – Installation des versions d’Android
Figure 1.3 – Le bloc notes que nous allons développer dans un TP
2 Les bases indispensables à toute application
2.1 L’univers Android
Dans ce tout premier chapitre, je vais vous présenter ce que j’appelle l’« univers Android »! Le système, dans sa genèse, part d’une idée de base simple, et très vite son succès fut tel qu’il a su devenir indispensable pour certains constructeurs et utilisateurs, en particulier dans la sphère de la téléphonie mobile. Nous allons rapidement revenir sur cette aventure et sur la philosophie d’Android, puis je rappellerai les bases de la programmation en Java, pour ceux qui auraient besoin d’une petite piqûre de rappel…;)
2.1.1 La création d’Android
QuandonpenseàAndroid,onpenseimmédiatementàGoogle,etpourtantilfautsavoirquecette multinationale n’est pas à l’initiative du projet. D’ailleurs, elle n’est même pas la seule à contribuer à plein temps à son évolution. À l’origine, « Android » était le nom d’une PME américaine, créée en 2003 puis rachetée par Google en 2005, qui avait la ferme intention de s’introduire sur le marché des produits mobiles. La gageure, derrière Android, était de développer un système d’exploitationmobileplusintelligent,quinesecontenteraitpasuniquementdepermettred’envoyer des SMS et transmettre des appels, mais qui devait permettre à l’utilisateur d’interagir avec son environnement (notamment avec son emplacement géographique). C’est pourquoi, contrairementàunecroyancepopulaire,iln’estpaspossiblededirequ’AndroidestuneréponsedeGoogle à l’iPhone d’Apple, puisque l’existence de ce dernier n’a été révélée que deux années plus tard.
C’est en 2007 que la situation prit une autre tournure. À cette époque, chaque constructeur équipaitsontéléphoned’unsystèmed’exploitationpropriétaire.Chaquetéléphoneavaitainsiunsystème plus ou moins différent. Ce système entravait la possibilité de développer facilement des applications qui s’adapteraient à tous les téléphones, puisque la base était complètement différente. Un développeur était plutôt spécialisé dans un système particulier et il devait se contenter de langages de bas niveaux comme le C ou le C++. De plus, les constructeurs faisaient en sorte de livrer des bibliothèques de développement très réduites de manière à dissimuler leurs secrets de fabrication. En janvier 2007, Apple dévoilait l’iPhone, un téléphone tout simplement révolutionnaire pour l’époque. L’annonce est un désastre pour les autres constructeurs, qui doivent s’aligner sur cette nouvelle concurrence. Le problème étant que pour atteindre le niveau d’iOS (iPhone OS), il aurait fallu des années de recherche et développement à chaque constructeur…
C’est pourquoi est créée en novembre de l’année 2007 l’Open Handset Alliance (que j’appellerai désormaisparsonsigleOHA),etquicomptaitàsacréation35entreprisesévoluantdansl’univers du mobile, dont Google. Cette alliance a pour but de développer un système open source (c’est-àdire dont les sources sont disponibles librement sur internet) pour l’exploitation sur mobile et
ainsiconcurrencerlessystèmespropriétaires,parexempleWindowsMobileetiOS.Cettealliance a pour logiciel vedette Android, mais il ne s’agit pas de sa seule activité.
L’OHA compte à l’heure actuelle 80 membres.
Figure 2.1 – Le logo de l’OHA, une organisation qui cherche à développer des standards open source pour les appareils mobiles
Depuissacréation,lapopularitéd’Androidatoujoursétécroissante.C’estauquatrièmetrimestre 2010 qu’Android devient le système d’exploitation mobile le plus utilisé au monde, devançant Symbian (le système d’exploitation de Nokia avant qu’ils optent pour Windows Phone). Désormais, on le retrouve non seulement dans les tablettes et smartphones, mais aussi dans les téléviseurs, les consoles de jeux, les appareils photos, etc.
2.1.2 La philosophie et les avantages d’Android
2.1.2.0.1 Open source Le contrat de licence pour Android respecte les principes de l’open source, c’est-à-dire que vous pouvez à tout moment télécharger les sources et les modifier selon vos goûts! Bon, je ne vous le recommande vraiment pas, à moins que vous sachiez ce que vous faites… Notez au passage qu’Android utilise des bibliothèques open source puissantes, comme par exemple SQLite pour les bases de données et OpenGL pour la gestion d’images 2D et 3D.
2.1.2.0.2 Gratuit (ou presque) Android est gratuit, autant pour vous que pour les constructeurs. S’il vous prenait l’envie de produire votre propre téléphone sous Android, alors vous n’auriezmêmepasàouvrirvotreporte-monnaie(maisboncouragepourtoutletravailàfournir!).En revanche, pour poster vos applications sur le Play Store, il vous en coûtera la modique somme de 25$. Ces 25$ permettent de publier autant d’applications que vous le souhaitez, à vie! :D
2.1.2.0.3 Facile à développer TouteslesAPImisesàdispositionfacilitentetaccélèrentgrandement le travail. Ces APIs sont très complètes et très faciles d’accès. De manière un peu caricaturale, on peut dire que vous pouvez envoyer un SMS en seulement deux lignes de code (concrètement, il y a un peu d’enrobage autour de ce code, mais pas tellement).
[[information]] | Une API, ou « interface de programmation » en français, est un ensemble de règles à suivre pour pouvoir dialoguer avec d’autres applications. Dans le cas de Google API, il permet en particulier de communiquer avec Google Maps.
2.1.2.0.4 Facile à vendre Le Play Store (anciennement Android Market) est une plateforme immense et très visitée; c’est donc une mine d’opportunités pour quiconque possède une idée originale ou utile.
2.1.2.0.5 Flexible Le système est extrêmement portable, il s’adapte à beaucoup de structures différentes. Les smartphones, les tablettes, la présence ou l’absence de clavier ou de trackball, différents processeurs… On trouve même des fours à micro-ondes qui fonctionnent à l’aide d’Android! ˆˆ Non seulement c’est une immense chance d’avoir autant d’opportunités, mais en plus Android est construit de manière à faciliter le développement et la distribution en fonction des composants en présence dans le terminal (si votre application nécessite d’utiliser le Bluetooth, seuls les terminaux équipés de Bluetooth pourront la voir sur le Play Store).
2.1.2.0.6 Ingénieux L’architecture d’Android est inspirée par les applications composites, et encourage par ailleurs leur développement. Ces applications se trouvent essentiellement sur internetetleurprincipeestquevouspouvezcombinerplusieurscomposantstotalementdifférents pourobtenirunrésultatsurpuissant.Parexemple,sioncombinel’appareilphotoavecleGPS,on peut poster les coordonnées GPS des photos prises.
2.1.3 Les difficultés du développement pour des systèmes embarqués
Il existe certaines contraintes pour le développement Android, qui ne s’appliquent pas au développement habituel!
Prenons un cas concret : la mémoire RAM est un composant matériel indispensable. Quand vous lancez un logiciel, votre système d’exploitation lui réserve de la mémoire pour qu’il puisse créer des variables, telles que des tableaux, des listes, etc. Ainsi, sur mon ordinateur, j’ai 4 Go de RAM, alors que je n’ai que 512 Mo sur mon téléphone, ce qui signifie que j’en ai huit fois moins. Je peux donc lancer moins de logiciels à la fois et ces logiciels doivent faire en sorte de réserver moins de mémoire. C’est pourquoi votre téléphone est dit limité, il doit supporter des contraintes qui font doucement sourire votre ordinateur.
Voicilesprincipalescontraintesàprendreencomptequandondéveloppepourunenvironnement mobile :
— Il faut pouvoir interagir avec un système complet sans l’interrompre. Android fait des choses pendant que votre application est utilisée, il reçoit des SMS et des appels, entre autres. Il faut respecter une certaine priorité dans l’exécution des tâches. Sincèrement, vous allez bloquer les appels de l’utilisateur pour qu’il puisse terminer sa partie de votre jeu de sudoku? :-°
— Comme je l’ai déjà dit, le système n’est pas aussi puissant qu’un ordinateur classique, il faudra exploiter tous les outils fournis afin de débusquer les portions de code qui nécessitent des optimisations.
— La taille de l’écran est réduite, et il existe par ailleurs plusieurs tailles et résolutions différentes.Votreinterfacegraphiquedoits’adapteràtouteslestaillesettouteslesrésolutions, ou vous risquez de laisser de côté un bon nombre d’utilisateurs.
— Autre chose qui est directement lié, les interfaces tactiles sont peu pratiques en cas d’utilisation avec un stylet et/ou peu précises en cas d’utilisation avec les doigts, d’où des contraintes liées à la programmation événementielle plus rigides. En effet, il est possible que l’utilisateur se trompe souvent de bouton. Très souvent s’il a de gros doigts. ˆˆ
— Enfin, en plus d’avoir une variété au niveau de la taille de l’écran, on a aussi une variété au niveaudelalangue,descomposantsmatérielsprésentsetdesversionsd’Android.Ilyaune variabilité entre chaque téléphone et même parfois entre certains téléphones identiques. C’est un travail en plus à prendre en compte.
Lesconséquencesdetellesnégligencespeuventêtreterriblespourl’utilisateur.Saturezleprocesseur et il ne pourra plus rien faire excepté redémarrer! Faire crasher une application ne fera en généralpascomplètementcrasherlesystème,cependantilpourraitbiens’interromprequelques temps et irriter profondément l’utilisateur.
Il faut bien comprendre que dans le paradigme de la programmation classique vous êtes dans votre propre monde et vous n’avez vraiment pas grand-chose à faire du reste de l’univers dans lequel vous évoluez, alors que là vous faites partie d’un système fragile qui évolue sans anicroche tant que vous n’intervenez pas. Votre but est de fournir des fonctionnalités de plus à ce système et faire en sorte de ne pas le perturber.
Bon, cela paraît très alarmiste dit comme ça, Android a déjà anticipé la plupart des âneries que vouscommettrezetaprisdesdispositionspouréviterdescatastrophesquiconduirontaublocage total du téléphone.;) Si vous êtes un tantinet curieux, je vous invite à lire l’annexe sur l’architecture d’Android pour comprendre un peu pourquoi il faut être un barbare pour vraiment réussir à saturer le système.
2.1.4 Le langage Java
Cette petite section permettra à ceux fâchés avec le Java de se remettre un peu dans le bain et surtout de réviser le vocabulaire de base. Notez qu’il ne s’agit que d’un rappel, il est conseillé de connaître la programmation en Java auparavant; je ne fais ici que rappeler quelques notions de base pour vous rafraîchir la mémoire! Il ne s’agit absolument pas d’une introduction à la programmation.
2.1.4.1 Les variables
La seule chose qu’un programme sait faire, c’est des calculs. Il arrive qu’on puisse lui faire afficherdesformesetdescouleurs,maispastoujours.Pourfairedescalculs,onabesoindevariables.
Ces variables permettent de conserver des informations avec lesquelles on va pouvoir faire des opérations. Ainsi, on peut avoir une variable radis qui vaudra 4 pour indiquer qu’on a quatre radis.Sionaunevariablecarottequivaut2,onpeutfairelecalculradis + carottedemanière à pouvoir déduire qu’on a six légumes.
2.1.4.1.1 Les primitives En Java, il existe deux types de variable. Le premier type s’appelle les primitives. Ces primitives permettent de retenir des informations simples telles que des nombres sans virgule (auquel cas la variable est un entier, int), des chiffres à virgule (des réels, float) ou des booléens (variable qui ne peut valoir que vrai (true) ou faux (false), avec les boolean).
[[attention]] | Cette liste n’est bien sûr pas exhaustive!
2.1.4.1.2 Les objets Lesecondtype,cesontlesobjets.Eneffet,àl’opposédesprimitives(variablessimples),lesobjetssontdesvariablescompliquées.Enfait,uneprimitivenepeutcontenir qu’une information, par exemple la valeur d’un nombre; tandis qu’un objet est constitué d’une ou plusieurs autres variables, et par conséquent d’une ou plusieurs valeurs. Ainsi, un objet peut lui-même contenir un objet! Un objet peut représenter absolument ce qu’on veut : une chaise, une voiture, un concept philosophique, une formule mathématique, etc. Par exemple, pour représenter une voiture, je créerai un objet qui contient une variable roue qui vaudra 4, une variable vitesse qui variera en fonction de la vitesse et une variable carrosserie pour la couleur de la carrosserie et qui pourra valoir « rouge », « bleu », que sais-je! D’ailleurs, une variable qui représente une couleur? Ça ne peut pas être une primitive, ce n’est pas une variable facile ça, une couleur! Donc cette variable sera aussi un objet, ce qui signifie qu’un objet peut contenir des primitives ou d’autres objets.
Maisdanslecode,commentreprésenterunobjet?Pourcela,ilvafalloirdéclarercequ’onappelle une classe. Cette classe aura un nom, pour notre voiture on peut simplement l’appeler Voiture, comme ceci :
// On déclare une classe Voiture avec cette syntaxe class Voiture {
// Et dedans on ajoute les attributs qu'on utilisera, par exemple le nombre de roues int roue = 4;
// On ne connaît pas la vitesse, alors on ne la déclare pas float vitesse;
// Et enfin la couleur, qui est représentée par une classe de nom Couleur
Couleur carrosserie;
}
Les variables ainsi insérées au sein d’une classe sont appelées des attributs.
Il est possible de donner des instructions à cette voiture, comme d’accélérer ou de s’arrêter. Ces instructions s’appellent des méthodes, par exemple pour freiner :
//Je déclare une méthode qui s'appelle "arreter" void arreter() {
//Pour s'arrêter, je passe la vitesse à 0 vitesse = 0;
}
En revanche, pour changer de vitesse, il faut que je dise si j’accélère ou décélère et de combien la vitesse change. Ces deux valeurs données avant l’exécution de la méthode s’appellent des paramètres. De plus, je veux que la méthode rende à la fin de son exécution la nouvelle vitesse. Cette valeur rendue à la fin de l’exécution d’une méthode s’appelle une valeur de retour. Par exemple :
// On dit ici que la méthode renvoie un float et qu'elle a besoin d'un float et d'un bo float changer_vitesse(float facteur_de_vitesse, boolean acceleration)
// S'il s'agit d'une accelération if(acceleration == true) { // On augmente la vitesse vitesse = vitesse + facteur_de_vitesse;
}else {
// On diminue la vitesse vitesse = vitesse - facteur_de_vitesse;
}
// La valeur de retour est la nouvelle vitesse return vitesse;
}
Parmi les différents types de méthode, il existe un type particulier qu’on appelle les constructeurs. Ces constructeurs sont des méthodes qui construisent l’objet désigné par la classe. Par exemple, le constructeur de la classe Voiture renvoie un objet de type Voiture :
// Ce constructeur prend en paramètre la couleur de la carrosserie
Voiture(Couleur carros) {
// Quand on construit une voiture, elle a une vitesse nulle vitesse = 0; carrosserie = carros;
}
On peut ensuite construire une voiture avec cette syntaxe :
Voiture v = new Voiture(rouge);
Construire un objet s’appelle l’instanciation.
2.1.4.2 L’héritage
Il existe certains objets dont l’instanciation n’aurait aucun sens. Par exemple, un objet de type
Véhicule n’existe pas vraiment dans un jeu de course. En revanche il est possible d’avoir des véhicules de certains types, par exemple des voitures ou des motos. Si je veux une moto, il faut qu’elle ait deux roues et, si j’instancie une voiture, elle doit avoir 4 roues, mais dans les deux cas elles ont des roues. Dans les cas de ce genre, c’est-à-dire quand plusieurs classes ont des attributs en commun, on fait appel à l’héritage. Quand une classe A hérite d’une classe B, on dit que la classe A est la fille de la classe B et que la classe B est le parent (ou la superclasse) de la classe A.
// Dans un premier fichier
// Classe qui ne peut être instanciée abstract class Vehicule {
int nombre_de_roues;
float vitesse;
}
// Dans un autre fichier // Une Voiture est un Vehicule class Voiture extends Vehicule {
}
// Dans un autre fichier // Une Moto est aussi un Vehicule class Moto extends Vehicule {
}
// Dans un autre fichier
// Un Cabriolet est une Voiture (et par conséquent un Véhicule) class Cabriolet extends Voiture {
}
Le mot-clé abstract signifie qu’une classe ne peut être instanciée.
[[information]]|Uneméthodepeutaussiêtreabstract,auquelcaspasbesoind’écriresoncorps. En revanche, toutes les classes héritant de la classe qui contient cette méthode devront décrire une implémentation de cette méthode.
Pour contrôler les capacités des classes à utiliser les attributs et méthodes les unes des autres, on a accès à trois niveaux d’accessibilité :
— public, pour qu’un attribut ou une méthode soit accessible à tous.
— protected, pour que les éléments ne soient accessibles qu’aux classes filles.
— Enfinprivate,pourquelesélémentsnesoientaccessiblesàpersonnesicen’estlaclasse elle-même.
On trouve par exemple :
// Cette classe est accessible à tout le monde public abstract class Vehicule {
// Cet attribut est accessible à toutes les filles de la classe Vehicule protected roue;
// Personne n'a accès à cette méthode. abstract private void decelerer();
}
Enfin, il existe un type de classe mère particulier : les interfaces. Une interface est impossible à instancier et toutes les classes filles de cette interface devront instancier les méthodes de cette interface — elles sont toutes forcément abstract.
//Interface des objets qui peuvent voler interface PeutVoler {
void décoller();
}
class Avion extends Vehicule implements PeutVoler {
//Implémenter toutes les méthodes de PeutVoler et les méthodes abstraites de Vehicule
}
2.1.4.3 La compilation et l’exécution
Votre programme est terminé et vous souhaitez le voir fonctionner, c’est tout à fait normal. Cependant, votre programme ne sera pas immédiatement compréhensible par l’ordinateur. En effet, pour qu’un programme fonctionne, il doit d’abord passer par une étape de compilation, qui consiste à traduire votre code Java en bytecode. Dans le cas d’Android, ce bytecode sera ensuite luparunlogicielquis’appellelamachinevirtuelleDalvik.Cettemachinevirtuelleinterprèteles instructionsbytecodeetvalestraduireenunautrelangagequeleprocesseurpourracomprendre, afin de pouvoir exécuter votre programme.
2.1.5 En résumé
— Google n’est pas le seul à l’initiative du projet Android. C’est en 2007 que l’Open Handset Alliance (OHA) a été créé et elle comptait 35 entreprises à ses débuts.
— La philosophie du système réside sur 6 points importants : il fallait qu’il soit open source, gratuit dans la mesure du possible, facile à développer, facile à vendre, flexible et ingénieux.
— Il ne faut jamais perdre à l’esprit que vos smartphones sont (pour l’instant) moins puissants et possèdent moins de mémoire que vos ordinateurs!
— Il existe un certain nombre de bonnes pratiques qu’il faut absolument respecter dans le développementdevosapplications.Sansquoi,l’utilisateurauratendanceàvouloirlesdésinstaller.
— Nebloquezjamaislesmartphone.N’oubliezpasqu’ilfaitaussiautrechoselorsquevous exécutez vos applications.
— Optimisezvosalgorithmes:votresmartphonen’estpascomparableàvotreordinateur en terme de performance.
— Adaptez vos interfaces à tous les types d’écran : les terminaux sont nombreux.
— Pensez vos interfaces pour les doigts de l’utilisateur final. S’il possède des gros doigts et que vous faites des petits boutons, l’expérience utilisateur en sera altérée.
— Si possible, testez vos applications sur un large choix de smartphones. Il existe des variations entre les versions, les constructeurs et surtout entre les matériels.
— Une bonne compréhension du langage Java est nécessaire pour suivre ce cours, et plus généralement pour développer sur Android.
2.2 Installation et configuration des outils
Avant de pouvoir entrer dans le vif du sujet, nous allons vérifier que votre ordinateur est capable de supporter la charge du développement pour Android, puis, le cas échéant, on installera tous
les programmes et composants nécessaires. Vous aurez besoin de plus de 1 Go pour tout installer. Et si vous possédez un appareil sous Android, je vous montrerai comment le configurer de façon à pouvoir travailler directement avec.
Encore un peu de patience, les choses sérieuses démarreront dès le prochain chapitre.
2.2.1 Conditions initiales
De manière générale, n’importe quel matériel permet de développer sur Android du moment que vous utilisez Windows, Mac OS X ou une distribution Linux. Il y a bien sûr certaines limites à ne pas franchir.
Voyonssivotresystèmed’exploitationestsuffisantpourvousmettreautravail.Pourunenvironnement Windows, sont tolérés XP (en version 32 bits), Vista (en version 32 et 64 bits) et 7 (aussi en 32 et 64 bits). Officieusement (en effet, Google n’a rien communiqué à ce sujet), Windows 8 est aussi supporté en 32 et 64 bits.
[[question]] | Et comment savoir quelle version de Windows j’utilise?
C’estsimple,si vous utilisez Windows7 ou Windows Vista, appuyez en même temps sur la touche Windows et sur la touche ||R||. Si vous êtes sous Windows XP, il va falloir cliquer sur Démarrer puis sur Exécuter. Dans la nouvelle fenêtre qui s’ouvre, tapez winver. Si la fenêtre qui s’ouvre indique Windows 7 ou Windows Vista, c’est bon, mais s’il est écrit Windows XP, alors vous devezvérifier qu’il n’est écrit à aucun moment 64 bits. Si c’est le cas, alors vous nepourrezpas développer pour Android.