Les outils et le framework Android
Découverte de l'environnement de développement d'Android.
Outils
Le développement sur Android est possible grace aux outils fournis par Google. Contrairement à l'iPhone ou WindowsPhone, il peut se faire depuis n'importe quel OS.
Pour développer une application Android il faut donc :
- un ordinateur avec assez de RAM (pour supporter tous les outils)
- le JDK
- le SDK Android, qui comprends plusieurs outils indispensables
- optionnellement Eclipse et le plugin "ADT"
- un ou plusieurs émulateurs pour tester l'application sans passer par un vrai téléphone
- éventuellement un ou plusieurs terminaux pour tester l'application en condition réelle
Depuis peu, il existe un "bundle" qui inclus tous les logiciels nécessaires. http://developer.android.com/sdk/index.html.
Bien pratique : le plugin Eclipse
L'installation du SDK android met à disposition plusieurs outils en lignes de commandes. Pour simplifier l'utilisation, il existe un plugin Eclipse qui centralise ces outils.
Il permet par exemple d'installer les différentes plateformes (versions d'Android), ou de configurer les émulateurs, et de gérer les mises à jour.
Android SDK Manager
Il permet de gérer les composants du SDK. L'utilisation principale est de télécharger les différentes versions des SDK.
Il faut inclure au choix la ou les versions de base sur laquelle on souhaite développer l'application.
Aujourd'hui, en 2013, c'est la version 2.3 qui permet de cibler un maximum d'utilisateurs. Il est bien sûr possible de choisir une plateforme plus récente pour profiter de toutes les nouveautés, mais le public sera réduit.
De même, si vous récupérez des projets existants, il faudra télécharger la plateforme correspondante.
Android Virtual Device Manager (AVD Manager)
Il permet de configurer et de créer des terminaux virtuels pour tester nos applications durant le développement. On peut définir la version de la plateforme, ainsi que les propriétés du "terminal", comme la taille de l'écran, la quantité de mémoire, la présence d'un clavier, etc.
Documentation
La documentation du framework ainsi que des articles contenants des conseils et des exemples se trouvent sur le site d'Android http://developer.android.com. C'est la référence, en anglais.
Lors d'un développement d'une application, il est indispensable de choisir sur quelle version d'Android l'on va se baser.
Chaque version (Android 2.3, Android 4...) correspond à un nom commercial (Gingerbread, Ice cream sandwich) et à un code "API number". Ce code est important car il permet de se référer à la bonne documentation.
Plus d'infos sur les versions d'Android sur : http://developer.android.com/about/dashboards/index.html
Dissection d'une application
Nous utiliserons Eclipse et le plugin Android dans la mesure du possible.
Création de l'application
Lorsque nous créons un nouveau projet Android, Eclipse nous demande de choisir, en plus du nom et d'un dossier pour le stocker, la version de l'API que nous souhaitons utiliser.
Nous allons choisir la version d'Android 2.3 (Gingerbread), qui correspond à l'API number 10. Cela nous permettra de cibler le public le plus large possible (environ 80%), tout en profitant d'un certains nombre d'amélioration par rapport aux toutes premières versions.
Architecture d'une application
L'application n'est pas composée que du code, il y a aussi (au minimum !) :
- Le .project
- Le AndroidManifest.xml
- Les activities
- Les ressources (vues, chaines et médias )
Le fichier .project
C'est un fichier créé automatiquement par Eclipse. Il est indispensable pour Eclipse, mais pas pour Android.
Il contient les chemins et surtout la configuration du projet : quelle version de l'API utiliser, ainsi que les réglages de l'interface utilisateur d'Eclipse.
Le fichier AndroidManifest.xml
Indispensable à tout projet Android, c'est la fiche d'identité de notre application. Elle est remplie par le développeur.
Il contient les composants de notre application, à savoir :- la liste des activities Activity, c'est à dire des pages de notre application, avec leur noms et leur caractéristiques
- La liste des permissions uses-permission que demande l'application à l'utilisateur. Par exemple utiliser son carnet d'adresse, ou se connecter à internet.
- La liste des conditions d'utilisation uses-feature de notre application. Vu la diversité des terminaux Android, on peut indiquer les options indispensables au bon fonctionnement de notre application : un appareil photo, le GPS, un clavier... etc.
La liste des permissions est disponible : http://developer.android.com/reference/android/Manifest.permission.html
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="fr.cnam.hello" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="10" android:targetSdkVersion="10" /> <uses-feature android:name="android.hardware.camera" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme"> <activity android:name=".MainActivity" android:label="@string/title_activity_main" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest>
Les activities
L'application peut-être composée de une ou plusieurs classes héritant d'Activity.
Ces classes représentent les points d'entrée de notre application, et nous permettrons d'être notifié du cycle de vie de notre application, comme le démarrage ou la mise en pause de l'application.
C'est dans ces méthodes (onCreate, onPause, etc) que l'on va intégrer notre code et développer notre application !
Tous les détails sur le cycle de vie des activities : http://developer.android.com/reference/android/app/Activity.html
package fr.cnam.hello; import android.os.Bundle; import android.app.Activity; public class MainActivity extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } }
Les resources
Le dossier res contient les ressources de l'applications, c'est à dire les vues, les traductions, et les médias. Tous ces élements ont la particularité d'être indexé automatiquement par Android dans la classe spéciale R.Les vues
La partie affichage d'une application Android peut être gérée par du code Java, mais plus généralement, on utilise des fichiers XML.
L'avantage c'est la séparation nette entre le code de l'UI et l'intelligence, et en plus Android nous propose un outil de mise en page visuel.
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" > <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:layout_centerVertical="true" android:text="@string/hello_world" /> </RelativeLayout>
Les textes
Tous les textes de l'application destinés aux humains doivent être placés dans des fichiers XML.
L'intérêt majeur de ce système est qu'il suffira de prévoir plusieurs fichiers avec les mêmes textes pour traduire une application par exemple.
<resources> <string name="app_name">Hello</string> <string name="hello_world">Hello world!</string> <string name="menu_settings">Reglages</string> <string name="title_activity_main">MainActivity</string> </resources>
Les medias
Etant donnée la disparité des terminaux et en particulier de la taille des écrans et de leur résolution, Android nous permet de prévoir plusieurs versions de la même image.
Par exemple, le logo de l'application (visible dans le menu du téléphone) fera 36 pixels pour les petits écrans et 96 pixels pour les plus grands, on fournira donc plusieurs fichiers.
Les variantes existantes sont, par ordre décroissant de résolution : drawable-xhdpi, drawable-hdpi, drawable-ldpi, drawable-mdpi. Chaque variante correspond un dossier contenant les images au adaptées au format.
Chaque téléphone "sait" de quelle variante il fait partie, et donc dans quel dossier correspondant il doit récupérer ces images.
La classe R
La classe R est générée automatiquement par Android lorsque l'on tape du code ou que l'on crée des ressources.
Elle indexe toutes les ressources de l'application pour nous permettre de les utiliser dans le code Java ou dans les XML.
Depuis le code java, on peut acceder à une ressource avec sa catégorie et son nom : R.string.hello_world.
Depuis le code XML, on peut acceder à une ressource avec sa catégorie et son nom : @string.hello_world.
/* AUTO-GENERATED FILE. DO NOT MODIFY. * * This class was automatically generated by the * aapt tool from the resource data it found. It * should not be modified by hand. */ package fr.cnam.hello; public final class R { public static final class attr { } public static final class drawable { public static final int ic_action_search=0x7f020000; public static final int ic_launcher=0x7f020001; } public static final class id { public static final int menu_settings=0x7f070000; } public static final class layout { public static final int activity_main=0x7f030000; } public static final class menu { public static final int activity_main=0x7f060000; } public static final class string { public static final int app_name=0x7f040000; public static final int hello_world=0x7f040001; public static final int menu_settings=0x7f040002; public static final int title_activity_main=0x7f040003; } public static final class style { public static final int AppTheme=0x7f050000; } }
