Layouts

Bonjour à tous.

Maintenant que nous savons comment installer Android sur votre machine, et comment créer une application simple, nous allons apprendre à créer layouts en Android. Dans Android, layouts sont créés à l'aide de fichiers XML, avec une structure de langue très rigide et standardisée, mais aussi très simple et didactique, grâce à l'excellente structure créée par Google.

Il existe plusieurs types de layout dans Android: FrameLayout, LinearLayout, TableLayout, entre autres. Dans cette sujet, nous allons aborder principalement les 3 dispositions citées dans ce paragraphe.

FrameLayout

Le FrameLayout est le layout la plus fondamentale qui existe dans Android. Dans cette layout, nous avons seulement une structure de layout stockée. Toutefois, cette structure peut être une autre layout. Cette layout est souvent utilisée dans les layouts génériques, comme des Tabs et des écrans dont le layout change tout au long de son exécution. Nous allons utiliser cette layout comme une base pour enseigner plusieurs concepts de base de layout dans Android.

Par exemple, dans Android, il existe différents types de composants graphiques:

• TextView → Affiche un texte sur l'écran. Il est certainement le graphique composant plus utilisé dans Android.
• ImageView →  Affiche une image ou simplement une fenêtre sur l'écran. Chaque fois que vous présentez une image ou montrer à l'utilisateur une fenêtre de couleur, par exemple, ce composant est utilisé.
• EditText →  Les composants ci-dessus fournissent des informations sur l'écran. Mais le EditText obtient un texte tapé par l'utilisateur, qui peut être utilisé pour interagir avec l'application Android.
• Button →  Cette composante est la plus commune dans toutes les système du layout. Dans cette composante, une action est effectuée après l'utilisateur clique.
• CheckBox → Un composant qui a essentiellement deux valeurs: vrai ou faux. Très utilisé pour représenter les paramètres du système.
• RadioGroup → Élément très utile de montrer les différentes options figurant sur l'écran, où seule l'une des options doit être cliqué. Largement utilisé dans les questions à choix multiples.

E existem diversos parâmetros para cada componente gráfico em um layout em Android. Para entender bem como são esses parâmetros, é demonstrado abaixo o uso de alguns desses componentes em um FrameLayout. Abaixo é mostrado o código-fonte do XML que cria o layout.

Et il y a plusieurs paramètres pour chaque composant graphique dans une layout dans Android. Pour bien comprendre comment ces paramètres sont indiquées, au-dessous est représentée l'utilisation de certains de ces composants dans un FrameLayout. Nous avons suivante, le source code du XML que crée le layout.

Et le layout genéré.

Dans le source ci-dessus, nous avons quelques paramètres, qui sont expliquées ci-dessous:

• android:layout_width="match_parent" → Dans la création de layouts dans Android, Il faut toujours appeler un paramètre en utilisant le préfixe "android:". Dans ce cas, le suffixe du paramètre est "layout_width". Ce paramètre définit la taille de la largeur de l'écran que nous créons. Cette taille peut être une taille fixe (en pixels, density pixels, ou d'autres unités de mise en forme) ou tailles extensibles. Dans ce cas, il est d'une taille extensible. Il y a 3 tailles extensible dans Android:
• fill_parent → Avec cette option, la taille du paramètre est au maximum (c'est à dire la taille de l'écran en cours). Par exemple, si l'écran est de 800 x 600 pixels et si le FrameLayout a le paramètre android:layout_width="fill_parent", la largeur dy layout de l'écran sera 600 pixels. Dans le API 8 (Froyo, Android 2.2), cette option a été abandonee, et remplacé par l'option "match_parent".
• wrap_content → Avec cette option, la taille du paramètre sera minimale, basée sur les composants-enfant de la configuration actuelle. Par exemple, si nous définissons la largeur du layout actuelle, avec le paramètre layout_width comme suit: android:layout_width="wrap_content", la largeur de l'écran sera le taille du composant-enfant de ce layout. Dans le cas de XML que nous analysons, votre composant enfant est un TextView. Si, par exemple, ce TextView a une taille de 20 x 20 (largeur x hauteur) pixels, donc la taille du layout sera le même. C'est ce que wrap_content fait. Si nous avions fill_parent  en la place, la taille du layout ne serait pas 20 x 20 pixels, mais les 800 x 600 pixels, équivalente à la taille de l'écran mobile.
• match_parent → Maintient la taille hérité par le composant-parent. S'il n'y a pas de composant parent, la taille sera maximale (c'est à dire, la taille de l'écran). Dans ce XML, nous avons une TextView et son composant-parent, qui est un FrameLayout. Si nous mettons dans le TextView le paramètre android:layout_width="match_parent", la largeur de l'écran en cours sera la même largeur du FrameLayout.
• android:layout_height="match_parent" → Ce paramètre définit la hauteur de l'écran que nous créons.
• android:gravity="center_horizontal" → Ce paramètre définit l'alignement des composants de cette layout a. Dans ce cas, l'alignement  sera au le centre et aussi horizontal.
• android:text="Exemplo" → Ce paramètre définit le texte du composante de courant.

De nombreux concepts ont été expliqué ci-dessus. Pour mieux les comprendre, nous allons modifier et tester les options une par une. Par exemple, ci-dessous, nous avons le même XML précédent, mais cette fois avec le paramètre android:gravity du composant TextView, changé de "center_horizontal" à "center_vertical".

  

Et ci-dessous, nous avons le même XML comme ci-dessus, mais cette fois avec le paramètre android:gravity du composant TextView changé de "center_horizontal" à "center".

Nous allons continuer à modifier les paramètres des composants, afin de mieux comprendre le fonctionnement de chacun. Ci-dessous le layout résultante quand on modifier les paramètres android: layout_width et android: layout_height à "match_parent" à "wrap_content".

Ainsi, la taille du FrameLayout devient la même taille du TextView. Difficile à comprendre? Donc, nous allons colorer le TextView:

Le résultat est le suivant:

Maintenant, il est facile de comprendre que la taille de FrameLayout est devenu la même taille de la TextView. Si nous changeons le paramètres android:layout_width et android:layout_height de FrameLayout du "wrap_content" au "match_parent" (quelle est la valeur d'origine, exposée dans la premiere image de ce sujet), nous avons le résultat suivant.

Autrement dit, dans l'exemple précédent, la taille de FrameLayout devient la même taille que la TextView par l'utilisation de "wrap_content". Maintenant, le taille du FrameLayout est devenu le taille de l'écran mobile, à l'aide de "match_parent". La compréhension de ces concepts du taille extensible de l'écran est TRÈS IMPORTANT dans le développement de tous layout de Android. Il est très important de maîtriser ces concepts, sinon la création de layout dans Android va devenir beaucoup plus compliqué.

Après l'explication du FrameLayout, est représenté ci-dessous le XML précédent avec quelques plus d'options, afin de laisser un plus élégant texte affiché.

Le résultat de cette nouvelle XML est:

Dans ce nouveau XML, nous changeons la couleur du FrameLayout, du noir (couleur par défaut) au bleu, à travers le paramètre android:background avec la valeur "#2244AA", qui est un bleu doux. Mais pourquoi la majorité de l'écran est de couleur blanche? Parce que c'est la couleur de la TextView (via l'option android:background="#FFFFFF"). Comme les paramètres de taille de l’écran du FrameLayout et TextView sont "match_parent", le taille de l'écran est le taille du TextView. Cependant, nous avons un nouveau paramètre dans le FrameLayout: android:padding="5dp". Quel est ce paramètre? Avec ce paramètre, est créé une frontière intérieure entre le FrameLayout et TextView, avec 5 dp du taille. Le concept de “dp” peut être vu ici.

Ainsi, comme la couleur de la FrameLayout est bleu, et le TextView est blanc, nous avons un contraste à l'écran, donnant l'impression que une frontière a été créé. Poursuivant l'explication, nous avons des options android:textSize (la taille du texte), android:textStyle (de style de texte, qui dans ce cas est en gras), et android:textColor (couleur du texte, qui dans ce cas est rouge).

Maintenant, nous allons parler d'autres types du layout.

LinearLayout

En FrameLayout nous avons une unique composante de l'enfant. Mais dans LinearLayout, nous avons plusieurs. Cette layout convient pour différents cas comme structures sur l'écran dans un mode linéaire. Dans cette layout, nous avons un paramètre qui n'existait pas dans FrameLayout, le android:orientation. Il a les possibilités “vertical” et “horizontal”. Pour démontrer le fonctionnement de ce paramètre, nous allons utiliser un autre XML.

Maintenant, nous avons plus d'un composant à l'écran. Le résultat de XML est:

C'est à dire, nous avons 2 TextViews, une sous l'autre, en position verticale. Comment le TextViews ont des paramètres android:layout_width="match_parent" et android:layout_height="wrap_content", nous avons la largeur à la taille maximale, et de la hauteur avec une taille minimum (la taille du TextView). Ci-dessous, nous avons une inversion de ces valeurs lorsque l'orientation du LinearLayout est horizontal.

Voici le résultat:

Comme les TextViews sont proches, nous prenons un espacement entre eux. Ceci est illustré dans le code XML suivant:

Voici le résultat:

Ce qui a été ajouté est le paramètre android:layout_margin="5dp". Il a créé une frontière extérieure (à ne pas confondre avec padding, qui est une marge interne) entre le 2 TextViews. Pourtant, les textes sont " collé" dans TextView. Ensuite, nous utilisons le padding pour donner un espacement interne dans les textes.

Voici le résultat: 

Pour conclure cette explication du LinearLayout, nous parler de paramètre layout_weight. Voici un nouvelle XML.

Dans ce XML, nous incluons un nouveau TextView, et modifier l'orientation du LinearLayout de l'horizontale à la verticale. Cependant, nous incluons le paramètre android:layout_weight="1". Ce paramètre donne la priorité à la taille de TextView dans lequel il est fixé (dans ce cas, le premier TextView). En d'autres termes, il améliore le taille de la largeur/hauteur de cette composante, remplace l'efficacité (rendant utile l'opération) du paramètres android:layout_width et android:layout_height. Ainsi, il "s'étend" la taille de ce TextView. Le résultat est:

Et maintenant, le résultat lorsque nous avons créé android:layout_weight="1" aussi dans le deuxième TextView.

Toujours sur le troisième.

Le paramètre layout_weight donne le “poids” de chaque composant. Comme dans l'image précédente tous ont le même poids, ils occupent la même place sur l'écran. Cependant, ce paramètre remplace les paramètres android:layout_width et android:layout_height. Pour finaliser l'explication de layout_weight, ce qui arrive quand nous avons placé toute les TextView comme android:layout_weight="1", mais le première TextView comme android:layout_weight="2"?

C'est à dire, il a équilibré le poids des composants en fonction de la valeur des paramètres android:layout_weight dans chaque TextView.

Maintenant, nous allons en apprendre un peu sur le TableLayout.

TableLayout

Cette layout est couramment utilisé lorsque nous avons besoin de lister plusieurs composants en une ligne, le long d'un même écra. Par exemple, pour créer une layoutavec 18 TextView de 3 par 3, divisé le long des 6 lignes.

Pour créer un layout comme celle-ci, nous pourraient utiliser 6 LinearLayouts. Cependant, nous aurions un très grand source en XML, plus beaucoup de mémoire sur Android. La solution dans ce cas serait d'utiliser un TableLayout.

Pour signaler que certains composants de TableLayout être utilisés dans la même ligne, est utilisée le composant TableRow. Voici un exemple de son utilisation:

Et le résultat:

Pour l'exemple ci-dessus, on peut déduire l'effet d'une TableLayout. Si nous n'utilisons pas le composant TableRow, le TableLayout deviendrait un LinearLayout.

Pour mieux comprendre le fonctionnement de TableLayout, nous allons faire un exercice. Nous allons créer un layout avec 6 lignes, chacune contenant 3 TextView de taille égale. Le résultat sera le layout ci-dessous. 

Vous pouvez déjà voir que le code source XML généré sera énorme (plus de 250 lignes pour les deux cas), parce que nous devons reproduire beaucoup de code pour créer ces 18 TextViews. Une astuce pour éviter ce travail retaper est de créer un style pour notre TextView. Pour créer un style, nous devons créer un fichier XML dans le dossier res/values, appelé styles.xml.

Dans ce fichier, nous allons créer la forme générique de notre TextViews. Ci-dessous est montré comment serait la syntaxe de ce fichier.

Maintenant, nous devons mettre ce nouveau style dans notre XML. Alors, se traduirait par un fichier XML avec seulement 110 lignes, plus de la moitié de la taille de lignes de XML sans l'aide de styles.

-----

Avec ces trois types du layout, nous pouvons créer une immense quantité de layouts dans Android. Il existe d'autres types du layout (et d'autres éléments visuels), qu'avec le temps, nous allons voir ici sur le blog.

Si quelqu'un a une question, suggestion ou critique, sentir à l'aise.

Création du premier programme

Bonjour à tous.

Maintenant que je l'ai expliqué comment installer Eclipse et Android, nous allons commencer à s'attaquer à la création de programmes pour Android.

La création d'un programme dans Android peut être divisé en plusieurs étapes.

Étape 1 - Créer le projet Android dans Eclipse

Pour créer un programme dans Android, nous devons d'abord créer un projet pour ce programme. L'image ci-dessous illustre ceci:

Ensuite, choisissez l'option "Android Application Project", comme indiqué ci-dessous.

Une nouvelle fenêtre où vous devrez entrer le nom du projet s'affiche. ExemploAndroid sera le nom utilisé pour ce projet. Notez que lorsque nous remplissons le nom du projet, la zone de texte "Package Name" est rempli avec le nom du package par défaut du projet.

Remarque: Un package est une structure de répertoire dans lequel les fichiers du projet seront séparés. Cela sera détaillé ci-dessous.

Notez également que la zone de texte "Build SDK" a la valeur "Android 2.3.3 (API 10)", et la zone de texte "Minimum Required SDK" a la valeur "API 8: Android 2.2 (Froyo)”. Cela signifie que la version minimale prise en charge pour cette application est de 2.2, et la 2.3.3 est recommandée. Ainsi, ce programme NE SERA PAS EXÉCUTÉ sur mobile avec des versions inférieures à 2.2 (en version 1.5 – Cupcake, 1.6 - Donut, et 2.1 - Eclair).

L'écran suivant dans la création du projet est présenté ci-dessous. Ici, nous avons l’option du layout pour les écrans du programme que nous créons. Dans ce cas, nous utilisons l'option "BlankActivity".

Enfin, nous avons le dernier écran avant la création de la conception de notre programme dans Android. Dans cet écran, nous choisissons le nom du fichier qui contiendra la première interface graphique de notre programme. Dans ce cas, nous avons choisi le nom activity_main.

A la fin de ce processus, notre projet sera créé:

Le contenu de chaque dossier de notre projet seront expliquées ci-dessous, dans l'étape suivante.

Étape 2 - Comprendre la structure de notre projet dans Android

Un projet de programme pour Android dispose d'une structure rigide définie. Il est divisé en:

• AndroidManifest.xml → Il s'agit du fichier principal de notre projet.
  
  Dans ce fichier XML, nous avons les paramètres généraux de notre programme, comme le numéro de version de notre programme (android:versionCode="1") et les versions de SDK minimum et maximum pris en charge. Dans ce cas, la version minimale du SDK est 8, correspondant à la version 2.2 (communément appelé Froyo), et le maximum est de SDK 10, ce qui correspond à la version 2.3.3 (communément appelé Gingerbread).
  
  Nous avons également d'autres informations, comme l'icône de notre programme (android:icon="@drawable/ic_launcher"), le thème de layout ( android:theme="@style/AppTheme"), le nom du programme (android:label="@string/app_name"), son écran principal (android:name=".MainActivity"), et d'autres informations qui ne sont pas si important maintenant. 

• src/ → Dans ce dossier, nous avons tous le code source de Java.
  
  Lorsque nous avons créé notre projet, juste MainActivity.java est créé. C'est le fichier qui contient le premier écran du programme. Dans Android, un écran est connu comme une Activity. Donc, si nous voulons créer un écran, la classe actuelle doit étendre la classe Activity.
  
  Une Activity a un "cycle de vie", qui est le mieux expliqué ici, plus précisément dans la partie "Activity Lifecycle". En bref, une Activity (qui à partir de maintenant, nous allons appeler “écran”) a des événements qui sont déclenchés lorsque la mise au point du programme va à ce premier écran (onCreate), lorsque le focus va au programme (onResume), quand nous minimisons le programme (onPause) et lorsque nous avons fermé le programme (onDestroy), entre autres.
  
  Chaque écran doit OBLIGATOIRE posséder une interface graphique. Pour cela, nous mettons en œuvre la méthode setContentView() dans le méthode onCreate.
  
  Dans notre programme, nous avons mis le layout du MainActivity avec le layout du activity_main, qui est défini comme un argument du méthode setContentView(). Ainsi, nous avons l'écran, et aussi votre layout, mis en œuvre.
  
  D'autres explications de la source de MainActivity (par exemple, qui est le méthode onCreateOptionsMenu et parce que l'argument de la méthode setContentView() est R.layout.activity_main et pas simplement activity_main) il sera expliqué ci-dessous.
  
  
  

• res/ → Dans ce dossier, nous avons d'autres fichiers de configuration, comme les strings, les menus, les couleurs, les styles de layout, ainsi tous les fichiers multimédias (image, audio et vidéo) de notre programme.
  
  Notez dans la figure ci-dessous 4 dossiers dont le préfixe est drawable. Dans ce dossier sont stockées des images et des animations du projet. Mais pourquoi y a 4 dossiers et pas seulement un?
  
  Contrairement système mobile iOS, qui a seulement un type de téléphone mobile (iPhone) et un type de tablette (iPad), dans Android nous avons des centaines du téléphones et tabletes.
  
  Ainsi, nous aurons aussi une multitude de tailles possibles de l'écran dans une application Android. Ainsi, Google a créé 4 tailles différentes de l'écran: ldpi, mdpi, hdpi et xhdpi.
  
  Le acronyme ldpi signifie "low density of pixels", le mdpi signifie "medium density of pixels", le hdpi signifie "high density of pixels" et le xhdpi signifie "extremely high density of pixels". En bref, respectivement, nous pouvons interpréter ces acronymes comme “petite taille de l'écran” (par example, le téléphone portable Sony Ericsson Xperia Mini), “moyenne taille de l’écran” (Motorola Atrix), “grande taille de l’écran” (Samsung Galaxy S5) et “très grande taille de l’écran” (tablets). Plus de détails ici.
  
  Suite à notre détaillée, ont le dossier layout/ (où avoir toutes les interfaces graphiques à utiliser dans notre projet), le dossier menu/ (où nous avons tous les menus de notre projet), et le dossier values/ (où nous avons plusieurs types de structures communes à notre projet, strings, des thèmes de layout, les arrays, les couleurs, entre autres).
  
  Le layout de chaque écran d'Android sera mieux expliqué dans un autre sujet, ainsi que les menus. En ce qui concerne les strings, une question commune est de comprendre pourquoi nous avons besoin de déclarer toutes les strings dans un fichier XML, et pas dans le code source de Java.
  
  Il s'agit d'une bien pratique pensé du Google. Comme le système mobile Android est le plus utilisé dans le monde, étant utilisé dans des centaines de pays, il faut un support pour l'internationalisation. C'est à dire, il est un moyen bien facilité pour un programme dans une langue est changée en une autre langue. La solution trouvée est que Google crée la res/ dossier, un dossier spécifique pour stocker certaines structures de notre programme. Dans ce cas, les strings.
  
  Donc, il suffit de modifier uniquement le texte en fichier strings.xml pour notre programme prend en charge plusieurs langues. En bref, il est beaucoup plus simple de modifier le contenu du fichier strings.xml que de changer un par un, tous les fichiers Java de notre projet.

 

• R → C'est la classe la plus importante de tout programme dans Android. Ici sont stockés tous les emplacements de mémoire des composants utilisés dans notre programme (la classes du Java, fichiers XML, des images, des fichiers du audio et audio, etc).
  
  Ces lieux de mémoire sont essentiellement des nombres entiers. Si, par exemple, vouloir faire référence à un fichier d'image que le fichier ic_launcher.png (l'icône de notre programme), il suffit d'appeler l'emplacement de mémoire où cette image est stockée. Bien que cela semble assez compliqué, il est plus simple qu'il n'y paraît. Pour ce faire, il suffit d'appeler l'image comme suit: R.drawable.ic_launcher. En d'autres termes, R.<dossier de l’image>.<nom de l’image>.
  
  Par conséquent, la méthode setContentView() de la classe MainActivity.java, l'argument passé à la méthode est R.layout.activity_main, et pas activity_main.
  
  Remarque: Cette classe est auto-généré. Ainsi, même si nous changeons manuellement, il sera automatiquement re-généré de nouveau.

Maintenant que nous comprenons un peu la structure de notre projet, nous avons besoin pour exécuter notre projet de voir comment un programme d'Android est courses dans Eclipse. Ceci est expliqué dans l'étape ci-dessous.

Étape 3 - Exécution de notre projet
Pour exécuter notre projet, nous devons créer un émulateur du système mobile Android. C'est très simple à faire. Il suffit de cliquer dans le menu "Window" de la barre de menus d’Eclipse, et alors “AVD Manager” (Android Virtual Devices Manager, en d'autres termes, Virtuelle Gestionnaire de Périphériques d’Android). Puis, dans la nouvelle fenêtre a été ouverte, cliquez sur "New". Ensuite, la fenêtre ci-dessous s'ouvre.

Maintenant, il suffit de choisir le nom de notre émulateur, votre "Target" (version du SDK Android), le taille de votre écran dans le check button "Built-in", puis cliquez sur "Create AVD". Et voila, nous avons un émulateur du Android prêt à être utilisé.

Pour exécuter notre programme, nous avons cliqué avec le bouton droit de la souris sur le nom du projet dans le "Package Explorer" (ou même dans n'importe quel fichier de notre projet), et puis l'option "Run As". Puis, dans "Android Application". Ainsi, l'émulateur s'ouvre, et notre programme sera exécuté.

Ci-dessous, nous pouvons voir l'exécution de notre programme.

Et c’est tout! Nous créons notre premier programme sur Android! Il s'agit d'un programme simple qui affiche un texte sur l'écran.

-----

Dans les sections suivantes, seront présentés les programmes plus intéressants à mis en œuvre. Si quelqu'un a une question, suggestion ou critique, sentir à l'aise.

Commencer à programmer dans Android

Bonjour à tous.

Avant toute chose, il est nécessaire d'être expliqué étape par étape comment nous pouvons créer un environnement de développement pour les applications Android. Il est plusieurs postes à ce sujet dans Internet, mais que parfois certaines personnes me demande à ce sujet, j'ai décidé de créer ce poste.

La programmation dans les appareils Android peut être réalisée grâce à des langages de programmation comme Java et Scala, et en utilisant des outils tels que NetBeans, Eclipse, ou même par la ligne de commande.

Dans ce post sera montré l'approche la plus commune, c'est-à-utiliser le langage de programmation Java et Eclipse.

NOTE: Pour la programmation Android, utilisant Java et Eclipse, est exigé un minimum de connaissances en programmation informatique. Si vous ne remplissez pas ces conditions, ce post n'est pas approprié pour vous.

Les étapes d'installation de l'Android dans votre machine peuvent être divisés en plusieurs étapes.

Étape 1 - Télécharger le Java SDK

Nous ne pouvons pas oublier que c'est obligatoire d'avoir le Java Development Kit (SDK). Le téléchargement de ce programme de développement peut être accompli ici.

En outre, Java doit être configuré avec son Variables Enviroment. Si n'est pas, suivez ce lien.

Pour le téléchargement se faire, il est nécessaire d'accepter le contrat de licence pour la Java à l'aide. Pour accepter, cliquez simplement sur ​​le bouton, comme indiqué ci-dessous.

This step is common to download this package for all operating systems, like Linux, Windows and Mac.

Cette étape est commune pour télécharger ce fichier pour tous les systèmes d'exploitation, comme Linux, Windows et Mac.

Étape 2 - Télécharger le Eclipse Kepler
Maintenant que nous avons le SDK Java est installé sur l'ordinateur, la prochaine étape est de télécharger le framework Eclipse. Ce framework  est un IDE (Integrated Development Environment), un environnement de développement intégré pour les programmes informatiques. C'est dans cet environnement que les applications Android sont créés.

Le téléchargement de ce framework peut être fait ici. Ce site détecte automatiquement le système d'exploitation que vous utilisez, montrant les options pour télécharger ce package. Le package que nous devons télécharger est indiqué ci-dessous:

Il doit être téléchargé la version STANDARD d'Eclipse, et pas d'autres, comme EE Developers ou C / C + + Developers. 

Il s'agit de la dernière version d'Eclipse, connu sous le nom Eclipse Kepler. Pour télécharger, cliquez sur les liens situés à côté de l'image ci-dessus (dans ce cas, pour Windows). Ensuite, vous serez redirigé vers un nouveau site où le téléchargement sera effectué.

Étape 3 - Installez Android sur Eclipse
L'étape suivante consiste à installer Android sur Eclipse. L'Eclipse est un programme qui ne nécessite aucune installation. Son contenu téléchargé contient tout ce qu'il faut pour initialiser c'est l'exécution. Il est conseillé de laisser ce contenu dans un dossier comme C:/eclipse (pour Windows), ou /home/<utilisateur>/eclipse (dans le cas de Linux ou Mac).

Pour ouvrir l'Eclipse, cliquez simplement sur l'icône pourpre appelé "eclipse". Avant Eclipse est ouvert, il va vous demander d'être informé de la "espace de travail" où vous allez placer les projets qui seront développés. Dans mon cas, j'ai choisi le chemin C:/workspace (pour Windows) et /home/<utilisateur>/workspace (dans le cas de Linux ou Mac).

Ensuite, Eclipse s'ouvre, et ce que nous aurons à l'écran sera la suivante:

Maintenant, nous devons installer Android dans Eclipse. Pour cela, il faut cliquer sur l'option Help dans la barre de menu, puis cliquez sur Install New Software. Après cela, vous devez cliquer dans "Add..." et donner le nom et le lien de ce que nous allons télécharger dans Eclipse. 

Le nom que j'utilise toujours est "Android SDK", et le lien (à placer dans le "Location:") est: https://dl-ssl.google.com/android/eclipse/. 

Après cela, nous devons confirmer les prochaines étapes (tous d'entre eux, même quand il est nécessaire de redémarrer Eclipse), et après 5 à 10 minutes, le nouveau look de Eclipse sera présent:

Now, there are a few new icons in Eclipse, including two icons that appear with the Android mascot, a sign that Android has been downloaded correctly on the machine.

Maintenant, il y a quelques nouvelles icônes dans Eclipse, y compris les deux icônes qui apparaissent avec la mascotte du Android, un signe que Android a été téléchargé correctement dans la machine.

Étape 4 - Actualiser l'Android SDK Manager

Maintenant que Android est installé, nous avons besoin de mettre à jour ses forfaits pour créer des applications pour plusieurs versions existantes d'Android (1.5, 1.6, 2.1, 2.2, 2.3, 3.0, 3.1, 4.0, 4.1, 4.2, 4.3, et la dernière 4.4). 

Pour ce faire, il suffit de cliquer sur l'icône qui apparaît avec la mascotte Android-dessus d'une flèche blanche. Cette icône ouvre le SDK Manager.

Maintenant, nous choisissons les versions d'Android (appels de l'API), nous voulons aller au développement. Le choix judicieux est tout. Toutefois, cette étape prend un certain temps. Préparez-vous a attendre plus de 1 heure. 

Avec le SDK mis à jour, il sera disponible quelques exemples (Samples) d'Android code source, ainsi que les bibliothèques spécialisées de Google, tels que Google Maps bibliothèque.

-----

Avec ces 4 étapes, maintenant nous pouvons commencer à créer nos premiers programmes dans Android. Mais que de sera vu dans un sujet à venir. 

Si quelqu'un a une question, suggestion ou critique, sentir à l'aise.