Programmation Android site du Zero cours
Sommaire
Sommaire . 2
Lire aussi .. 3
Créez des applications pour Android . 5
Partie 1 : Les bases indispensables à toutes applications 7
L'univers Android 7
La création d'Android .. 7
La philosophie et les avantages d'Android 8
Les difficultés du développement pour des systèmes embarqués 9
Le langage Java .. 10
La notion d'objet .. 10 L'héritage . 11
La compilation et l'exécution . 12
Installation et configuration des outils .. 13
Conditions initiales . 13
Le Java Development Kit 13
Le SDK d'Android 14
L'IDE Eclipse . 15
L'émulateur de téléphone : Android Virtual Device 19
Test et configuration .. 21
Configuration du vrai terminal .. 27
Configuration du terminal 27
Pour les utilisateurs Windows .. 28
Pour les utilisateurs Mac . 28
Pour les utilisateurs Linux .. 28
Et après ? 29
Votre première application . 30
Activité et vue 30
Qu'est-ce qu'une activité ? . 30
États d'une activité . 31
Cycle de vie d'une activité .. 32
Création d'un projet 34
Un non-Hello world! 38
Lancement de l'application . 42
Les ressources . 44
Le format XML .. 45
Les différents types de ressources . 46
L'organisation 48
Exemples et règles à suivre .. 49
Mes recommandations . 49
Ajouter un fichier avec Eclipse . 50
Petit exercice . 52
Récupérer une ressource 53
La classe R 53
Application .. 56
Application .. 57
Partie 2 : Création d'interfaces graphiques 58
Constitution des interfaces graphiques 59
L'interface d'Eclipse 59
Présentation de l'outil 59
Utilisation . 60
Règles générales sur les vues . 65
Différenciation entre un layout et un widget .. 65
Attributs en commun . 66
Identifier et récupérer des vues 67
Identification .. 67
Instanciation des objets XML 69
Les widgets les plus simples . 71
Les widgets 72
TextView .. 72
EditText . 72
Button 73
CheckBox 74
RadioButton et RadioGroup .. 75
Utiliser la documentation pour trouver une information 76
Calcul de l'IMC - Partie 1 . 78
Gérer les évènements sur les widgets . 81
Les Listeners . 81
Par héritage 82
Par une classe anonyme . 83
Par un attribut 84
Application .. 85
Calcul de l'IMC - Partie 2 . 86
Organiser son interface avec des layouts .. 90
LinearLayout : placer les éléments sur une ligne 90
Sommaire
Calcul de l'IMC - Partie 3.1 . 95
RelativeLayout : placer les éléments les uns en fonction des autres 98
Calcul de l'IMC - Partie 3.2 .. 102
TableLayout : placer les éléments comme dans un tableau .. 103
Calcul de l'IMC - Partie 3.3 .. 106
FrameLayout : un layout un peu spécial .. 108
ScrollView : faire défiler le contenu d'une vue 108
Les autres ressources 109
Aspect général des fichiers de ressources .. 110
Référence à une ressource . 112
Les chaînes de caractères .. 112
Application 113
Formater des chaînes de caractères .. 114
Les drawables 116
Les images matricielles . 116
Les images extensibles . 117
Les styles . 120
Les animations .. 121
Définition en XML . 122
Un dernier raffinement : l'interpolation .. 125
L'évènementiel dans les animations .. 125
TP : un bloc-notes 127
Objectif .. 127
Le menu 127
L'éditeur . 128
Spécifications techniques . 129
Fichiers à utiliser .. 129
Le HTML 129
L'animation .. 131
Liens 132
Déboguer des applications Android 132
Ma solution .. 134
Les ressources .. 134
Le code .. 140
Objectifs secondaires . 145
Boutons à plusieurs états . 145
Internationalisation .. 146
Gérer correctement le mode paysage 146
Des widgets plus avancés et des boîtes de dialogue 147
Les listes et les adaptateurs 147
Les adaptateurs . 148
Les vues responsables de l'affichage des listes : les AdapterView . 151
Plus complexe : les Adapters personnalisés .. 159
Amélioration : le ViewHolder pattern .. 162
Les boîtes de dialogue .. 163
Généralités .. 163
Application 164
La boîte de dialogue de base . 166
AlertDialog 166
Les autres widgets .. 167
Date et heure .. 168
Afficher des images . 170
Auto-complétion 171
Gestion des menus de l’application 174
Menu d'options .. 174
Créer un menu .. 174
Réagir aux clics . 177
Menu contextuel 178
Maintenant que vous maîtrisez les menus, oubliez tout .. 179
Pour aller plus loin : création de vues personnalisées .. 181
Règles avancées concernant les vues .. 181
Dimensions et placement d'une vue .. 181
Le dessin .. 183
Méthode 1 : à partir d'une vue préexistante 184
Méthode 2 : une vue composite 188
Méthode 3 : créer une vue à partir de zéro . 191
La construction programmatique .. 191 La construction par inflation 191 onMeasure .. 193 onDraw .. 194
Partie 3 : Annexes 195
L'architecture d'Android . 196
Le noyau Linux .. 196
Les bibliothèques pour Android . 197
Le moteur d'exécution Android .. 197
Les frameworks pour les applications 198
Les applications 198
Publier et rentabiliser une application 198
Préparez votre application à une distribution . 199
Modifications et vérifications d'usage . 200
Signer l'application .. 202
Lire aussi
Les moyens de distribution . 205
Google Play . 206
Les applications 207
Informations sur une application .. 209
Les autres types de distribution . 212
Rentabiliser votre application . 212
Créer un compte marchand pour Google checkout 213
Faire payer l'application 213
Ajouter de la publicité . 213
Freemium : abonnement ou vente de produits intégrés 217
Lire aussi
Le tutoriel que vous êtes en train de lire est en . Son auteur souhaite que vous lui fassiez part de vos commentaires pour l'aider à l'améliorer avant sa publication officielle. Notez que le contenu n'a pas été validé par l'équipe éditoriale du Site du Zéro.
Par Frédéric Espiau (DakuTenshi) et AndroWiiid
Mise à jour : 10/05/2012
Difficulté : Intermédiaire Durée d'étude : 2 mois
18 088 visites depuis 7 jours, classé 14/792
Bonjour à tous et bienvenue dans le monde merveilleux du développement d'applications 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
BugDroid, la mascotte d'Android 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'application de Google ? Hé 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. Heureusement, le Site du Zéro propose un cours et même un livre sur le Java.
Connaître un minimum de SQL pour les requêtes (ça tombe bien, le Site du Zéro propose un cours sur MySQL). 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 ça, 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 de pouvoir 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 !
Partie 1 : Les bases indispensables à toutes applications
L'univers Android
Dans ce tout premier chapitre, je vais vous présenter ce que j'appelle l'« univers Android » ! La genèse de ce système 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 des téléphones portables.
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
La création d'Android
Quand on pense à Android, on pense immédiatement à Google, et pourtant il faut savoir que cette 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 d'essayer de développer un système d'exploitation mobile plus intelligent, qui ne se contentait pas uniquement de permettre d’envoyer des SMS et transmettre des appels, mais qui devait permettre d'interagir avec la situation de l'utilisateur dans la nature (notamment avec sa position géographique). C'est pourquoi, contrairement à une croyance populaire, on peut affirmer qu'Android n'est pas une réponse de Google à l'iPhone d'Apple puisque l'existence de ce dernier n'a été révélée que 2 années plus tard.
C'est en 2007 que la situation prit une autre tournure. À cette époque, chaque constructeur équipait son téléphone d'un système d'exploitation propriétaire, prévenant ainsi la possibilité de développer aisément une application qui s'adapterait à tous les téléphones, puisque la base était 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ésormais par son sigle OHA), et qui comptait à sa création 35 entreprises évoluant dans l'univers 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 ainsi concurrencer les systèmes propriétaires, par exemple Windows Mobile et iOs. Android est le logiciel vedette de cette alliance, mais il ne s'agit pas de leur seule activité.
Il existe à l'heure actuelle plus de 80 membres dans l'OHA.
Android est à l'heure actuelle, le système d'exploitation pour smartphones et tablettes le plus utilisé.
Les prévisions en ce qui concerne la distribution d'Android sur le marché sont très bonnes avec de plus en plus de machines qui s'équipent de ce système. Bientôt, il se trouvera dans certains téléviseurs (vous avez entendu parler de Google TV peut-être ?) et les voitures. Android sera partout. Ce serait dommage de ne pas faire partie de ça, hein ?
La philosophie et les avantages d'Android
Open-source
Le contrat de licence pour Android respecte l’idéologie 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-sources puissantes comme par exemple SQLite pour les bases de données et OpenGL pour la gestion d'images 2D et 3D.
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'auriez même pas à ouvrir votre porte monnaie (par contre bon courage pour tout le travail à 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 !
Facile à développer
Toutes les API mises à disposition facilitent et accélèrent grandement 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).
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 du Google API, il permet en particulier de communiquer avec Google Maps.
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.
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 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).
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 internet et leur principe est que vous pouvez combiner plusieurs composants totalement différents pour obtenir un résultat surpuissant. Par exemple, si on combine l'appareil photo avec le GPS, on peut poster les coordonnées GPS des photos prises.
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.
Voici les principales contraintes à prendre en compte quand on développe pour un environnement 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. Votre interface graphique doit s'adapter à toutes les tailles et toutes les résolutions, ou vous risquez de laisser de côté un bon nombre d'utilisateurs.
Autre chose qui est directement liée, 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 boutons. 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 niveau de la langue, des composants matériels présents et des versions d'Android. Il y a une 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.
Les conséquences de telles négligences peuvent être terribles pour l'utilisateur. Saturez le processeur et il ne pourra plus rien faire excepté redémarrer ! Faire crasher une application ne fera en général pas complètement crasher le système, cependant il pourrait bien s'interrompre quelques 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 de manière négative.
Bon ça parait très alarmiste dit comme ça, Android a déjà anticipé la plupart des âneries que vous commettrez et a pris des dispositions pour éviter des catastrophes qui conduiront au blocage 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.
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 que vous devez connaître la programmation en Java pour être en mesure de suivre ce cours ; je ne fais ici que rappeler quelques notions de bases pour vous rafraîchir la mémoire !
La notion d'objet
La seule chose qu'un programme sait faire, c'est des calculs ou afficher des images. Pour faire des calculs, on a besoin de variables. Ces variables permettent de conserver des informations avec lesquelles on va pouvoir faire des opérations. En Java, il existe deux types de variables. Le premier type s'appelle les primitives. Ces primitives permettent de retenir des informations simples telles que des nombres sans virgules (auquel cas la variable est un entier, int), des chiffres à virgules (des réels, float) ou des booléens (variable qui ne peut être que vraie : true ou fausse : false, avec boolean).
Cette liste n'est bien sûr pas exhaustive !
Le second type, ce sont les variables objet. En effet, à l'opposé des primitives (les variables « simples »), il existe les objets : les variables « compliquées ».
En fait une primitive ne peut contenir qu'une information, par exemple la valeur d'un chiffre ; tandis qu'un objet est constitué d'une ou plusieurs autres variables. Ainsi, une variable objet peut elle-même contenir une variable objet ! Un objet peut représenter absolument ce qu'on veut : un concept philosophique, une formule mathématique, une chaise, une voiture Par définition, je ne peux représenter une voiture dans une variable primitive. Je peux cependant concevoir un objet auquel je donnerais quatre roues, un volant et une vitesse ; ce qui ressemblerait déjà pas mal à une voiture !
Prenons donc un exemple, en créant un objet Voiture. Pour cela, il va falloir déclarer une classe voiture, comme ceci :
Code : Java
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 :
Code : Java
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 :
Code : Java
Parmi les différents types de méthodes, 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. Construire un objet s'appelle l’instanciation.
Ainsi, tout à l'heure, en créant l'objet Voiture via l'instruction : classVoiture {}, nous avons en réalité instancié l'objet Voiture.
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, 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.
Code : Java
Le mot-clé abstract signifie qu'une classe ne peut être instanciée.
Une méthode peut aussi être abstract, auquel cas pas besoin d'écrire son corps. 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.
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. Code : Java
La compilation et l'exécution
Votre programme est terminé et vous souhaitez le voir fonctionner, c'est tout à faire 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 lu par un logiciel qui s'appelle la machine virtuelle Dalvik. Cette machine virtuelle interprète les instructions bytecode pour exécuter votre programme.
Installation et configuration des outils
Avant de pouvoir rentrer 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 2,11 Go pour tout installer. Et si vous possédez un terminal sous Android, je vais vous montrer comment le configurer de façon à pouvoir travailler directement avec.
Encore un peu de patience, les choses sérieuses démarrerons dès le prochain chapitre.
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.
Voyons si votre système d'exploitation est suffisant pour vous mettre au travail.
Pour un environnement 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).
Et comment savoir quelle version de Windows j'utilise ?
C'est simple, si vous utilisez Windows 7 ou Windows Vista, appuyez en même temps 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 devez vérifier qu'il n'est écrit à aucun moment 64 bits. Si c'est le cas, alors vous ne pourrez pas développer pour Android.
Sous Mac, il vous faudra Mac OS 10.5.8 ou plus récent et un processeur x86.
Sous GNU/Linux, utilisez une distribution Ubuntu plus récente que la 8.04. Enfin de manière générale, n'importe quelle distribution convient à partir du moment où votre bibliothèque GNU C (glibc) est au moins à la version 2.7.
Tout ce que je présenterai sera dans un environnement Windows 7.
Le Java Development Kit
En tant que développeur Java vous avez certainement déjà installé le JDK (pour « Java Development Kit »), cependant on ne sait jamais ! Je vais tout de même vous rappeler comment l'installer. En revanche, si vous l'avez bien installé et que vous êtes à la dernière version, ne perdez pas votre temps et filez directement à la prochaine section !
Un petit rappel technique ne fait de mal à personne. Il existe deux plateformes en Java :
le JRE (Java Runtime Environment), qui contient la JVM (Java Virtual Machine, rappelez-vous j'ai expliqué le concept de machine virtuelle dans le premier chapitre), les bibliothèques de base du langage ainsi que tous les composants nécessaires au lancement d'applications ou d'applets Java. En gros, c'est l'ensemble d'outils qui vous permettra d’exécuter des applications Java.
le JDK (Java Development Kit), qui contient le JRE (afin d’exécuter les applications Java), mais aussi un ensemble d'outils pour compiler et déboguer votre code ! Vous trouverez un peu plus de détails sur la compilation dans l'annexe sur l'architecture d'Android.
Rendez-vous ici et cliquez sur Download à côté de Java SE 6 Update xx (on va ignorer Java SE 7 pour le moment) dans la colonne JDK.
On vous demande ensuite d'accepter (Accept License Agreement) ou de décliner
(Decline License Agreement) un contrat de licence, vous devez accepter ce contrat avant de continuer.
Choisissez ensuite la version adaptée à votre configuration. Une fois le téléchargement terminé, vous pouvez installer le tout là où vous le désirez. Vous aurez besoin de 200 Mo de libre sur le disque ciblé.
Le SDK d'Android
C'est quoi un SDK?
Un SDK, c'est-à-dire un Kit de Développement dans notre langue, est un ensemble d'outils que met à disposition un éditeur afin de vous permettre de développer des applications pour un environnement précis. Le SDK Android permet donc de développer des applications pour Android et uniquement pour Android.
Pour se le procurer, rendez-vous ici et sélectionnez la version dont vous avez besoin. Au premier lancement du SDK, un écran de ce type s'affichera :
Les trois paquets que je vous demanderai de sélectionner sont Tools, Android 2.1 (API 7) et Extras, mais vous pouvez voir que j'en ai aussi sélectionné d'autres.
À quoi servent les autres paquets que tu as sélectionnés ?
Regardez bien le nom des paquets, vous remarquerez qu'ils suivent tous un même motif. Il est écrit à chaque fois
Android [un nombre] (API [un autre nombre]). La présence de ces nombres s'explique par le fait qu'il existe plusieurs versions de la plateforme Android qui ont été développées depuis ses débuts et qu'il existe donc plusieurs versions différentes en circulation.
Le premier nombre correspond à la version d'Android et le second à la version de l'API Android associée. Quand on développe une application, il faut prendre en compte au moins un de ces numéros (l'autre sera toujours le même pour une même version), puisqu'une application développée pour une version précise d'Android ne fonctionnera pas pour les version précédentes. J'ai choisi de délaisser les versions précédant la version 2.1 (l'API 7), de façon à ce que l'application puisse fonctionner pour 2.1,
2.2, 3.1 mais pas forcément pour 1.6 ou 1.5 !
Les API dont le numéro est compris entre 11 et 13 sont destinées aux tablettes graphiques. En théorie, vous n'avez pas à vous en soucier, les applications développées avec les API numériquement inférieures fonctionneront, mais il y aura des petits efforts à fournir en revanche en ce qui concerne l'interface graphique (vous trouverez plus de détails dans le chapitre consacré).
Vous penserez peut-être qu'il est injuste de laisser de côté les personnes qui sont contraintes d'utiliser encore ces anciennes versions, mais sachez qu'ils ne représentent que 1.2% du parc mondial des utilisateurs d'Android. De plus, les changements entre la version 1.6 et la version 2.1 sont trop importants pour être ignorés. Ainsi, toutes les applications que nous développerons fonctionneront sous Android 2.1 minimum. On trouve aussi pour chaque SDK des échantillons de code, samples, qui vous serons très utiles pour approfondir ou avoir un second regard à propos de certains aspects, ainsi qu'une API Google associée. Dans un premier temps, vous pouvez ignorer ces API, mais sachez qu'on les utilisera par la suite.
Une fois votre choix effectué, un écran vous demandera de confirmer que vous souhaitez bien télécharger ces éléments là. Cliquez sur Accept All puis sur Install pour continuer.
Si vous installez tous ces paquets, vous aurez besoin de 1.8 Go sur le disque de destination. Eh oui, Le téléchargement prendra un peu de temps.
L'IDE Eclipse
Un IDE est un logiciel dont l'objectif est de faciliter le développement, généralement pour un ensemble restreint de langages. Il contient un certain nombre d'outils, dont au moins un éditeur de texte - souvent étendu pour avoir des fonctionnalités avancées telles que l'auto-complétion ou la génération automatique de code - des outils de compilation et un débogueur. Dans le cas du développement Android, un IDE est très pratique pour ceux qui souhaitent ne pas avoir à utiliser les lignes de commande.
J'ai choisi pour ce tutoriel de me baser sur Eclipse : tout simplement parce qu'il est gratuit, puissant et recommandé par Google dans la documentation officielle d'Android. Vous pouvez aussi opter pour d'autres IDE compétents tels que IntelliJ IDEA, avec une extension ou encore MoSync.
Le tutoriel reste en majorité valide quel que soit l'IDE que vous sélectionnez, mais vous aurez à explorer vous-même les outils proposés puisque je ne présenterai ici que ceux d'Eclipse.
Cliquez pour choisir une version d'Eclipse à télécharger. J'ai personnellement opté pour Eclipse IDE for Java Developers qui est le meilleur compromis entre contenu suffisant et taille du fichier à télécharger. Les autres versions utilisables sont Eclipse IDE for Java EE Developers (je ne vous le recommande pas pour notre cours, il pèse plus lourd et on n'utilisera absolument aucune fonctionnalité de Java EE) et Eclipse Classic (qui lui aussi intègre des modules que nous n'utiliserons pas).
Il vous faudra 110 Mo sur le disque pour installer la version d'Eclipse que j'ai choisie.
Maintenant qu'Eclipse est installé, lancez-le. Au premier démarrage il vous demandera de définir un Workspace, un espace de travail, c'est-à-dire l'endroit où il créera les fichiers indispensables contenant les informations sur les projets. Sélectionnez l'emplacement que vous souhaitez.
Vous avez maintenant un Eclipse prêt à fonctionner mais pas pour le développement pour Android ! Pour cela, on va télécharger le plug-in (l'extension) Android Development Tools (que j'appellerai désormais ADT). Il vous aidera à créer des projets pour Android avec les fichiers de base, mais aussi à tester, à déboguer et à exporter votre projet en APK (pour pouvoir publier vos applications).
ADT n'est pas le seul add-on qui permette de paramétrer Eclipse pour le développement Android, le MOTODEV Studio For Android est aussi très évolué si vous le désirez.
Allez dans Help puis dans Install New Softwares (installer de nouveaux programmes). Au premier encart intitulé Work with:, cliquez sur le bouton Add qui se situe juste à côté. On va définir où télécharger ce nouveau programme. Dans l'encart Name écrivez par exemple ADT et dans location, copiez l'adresse ci-dessous :