L'article décrit les principales difficultés de création d'applications pour Android.
Les concepts de base de la programmation Android sont abordés.
A titre d'exemple, la création d'un jeu Sudoku à partir du livre Hello, Android - Ed Burnette est décrite.
Attention il y a beaucoup de captures d'écran.
1. Difficultés de développement
Android est un système d'exploitation unique. Le développeur de l'application doit connaître ses caractéristiques et ses nuances pour obtenir un bon résultat. Certains défis doivent être pris en compte lors de la conception (). Listons-les brièvement :
1) L'application nécessite deux (voire quatre) plus d'espace pour l'installation que la taille d'origine de l'application.
2) La vitesse de travail avec les fichiers sur le lecteur flash intégré diminue des dizaines de fois à mesure que l'espace libre diminue.
3) Chaque processus peut utiliser jusqu'à 16 Mo (parfois 24 Mo) de RAM.
2. Principes de développement d'applications productives pour Android
Pour travailler, vous avez besoin du SDK Android et d'Eclipse. Il explique comment tout installer et commencer.
Pour charger un projet dans Eclipse, procédez comme suit :
1) Décompressez le projet dans un dossier séparé de l'espace de travail Eclipse.
2) Sélectionnez l'élément de menu Fichier->Nouveau->Projet Android.
3) Dans la boîte de dialogue Nouveau projet Android, sélectionnez l'option Créer un projet à partir d'une source existante.
4) Dans le champ Emplacement, spécifiez le chemin d'accès au dossier contenant le projet. Cliquez sur Suivant.
Menu du programme
Le menu du jeu est décrit dans le fichier res/layout/main.xml. La description de l'interface peut être éditée au format XML ou sous forme d'interface rendue. Pour basculer, utilisez les onglets en bas de la zone d'affichage du contenu.
Généralement, les contrôles sont contenus dans un conteneur, dans notre cas un LinearLayout. Il organise tous les éléments dans une seule colonne.
Ressources
Veuillez noter que toutes les étiquettes de texte (android:text) prennent des données provenant de ressources. Par exemple, l'entrée android:text="@string/main_title" précise que le texte doit être recherché dans le fichier res/values/string.xml dans un nœud nommé main_title (Android Sudoku). La couleur de fond est également contenue dans les ressources (android:background="@color/background") mais dans le fichier color.xml (#3500ffff). Une erreur peut survenir lors de l'ouverture des fichiers de ressources dans l'éditeur. Mais vous pouvez toujours passer à l'affichage XML.
Les contrôles auxquels il faut accéder à partir du code doivent avoir un identifiant. Les boutons ont un identifiant (android:id="@+id/continue_button") afin qu'un gestionnaire de clics puisse être attaché au bouton. Le signe plus indique que vous devez créer un identifiant pour le bouton dans le fichier /gen/org.example.sudoku/R.java (public static final int continue_button=0x7f0b000b;). Ce fichier est généré automatiquement et il n'est pas recommandé de le modifier. Le fichier contient la classe R, via laquelle vous pouvez accéder à n'importe quel élément d'interface et à d'autres ressources.
Création de fenêtres
Envisageons de créer une fenêtre avec des informations sur le programme. La disposition de cette fenêtre se trouve dans le fichier /res/layout/about.xml. La classe Activity est décrite dans le fichier /src/org.example.sudoku/About.java. L'activité est associée au balisage dans le fichier AndroidManifest.xml. Ce fichier peut être visualisé soit via un éditeur, soit au format XML. Vous pouvez sélectionner différentes sections du fichier dans différents onglets de l'éditeur. La section Application contient les paramètres d'activité. Notez que le paramètre Theme est :style/Theme.Dialog. Cela fait que le style de la fenêtre ressemble davantage à une boîte de dialogue modale.
La fenêtre contenant des informations sur le programme est appelée depuis le cours de Sudoku en cliquant sur le bouton À propos. La classe Sudoku est écrite de manière à gérer l'événement Click lui-même (la classe publique Sudoku extends Activity implémente OnClickListener). La méthode public void onClick(View v) détermine quel bouton a déclenché l'événement et exécute le code correspondant. Pour afficher la fenêtre À propos, l'Intent correspondant est appelé.
cas R.id.about_button :
Intention i = new Intent(this, About.class);
startActivity(i);
casser;
Les gestionnaires d'événements peuvent également être installés sur des contrôles spécifiques. Par exemple, dans la classe Keypad, lors de la création de la classe, les gestionnaires des boutons individuels sont installés dans la méthode setListeners(). 
Dialogues simples
L'utilisateur doit avoir la possibilité de choisir le niveau de difficulté. Il s'agit d'un petit dialogue dans lequel vous devez choisir l'une des plusieurs options. Je suis très heureux que vous n'ayez pas besoin de créer une intention distincte pour cela, mais utilisez simplement la classe AlertDialog.
Regardons le processus de démarrage d'un nouveau jeu. L'utilisateur clique sur le bouton Nouveau jeu. Le gestionnaire de clics est une méthode de la classe Sudoku - onClick. Ensuite, la méthode openNewGameDialog est appelée, qui affiche la boîte de dialogue de sélection de difficulté et démarre le jeu avec le niveau de difficulté sélectionné. Cette boîte de dialogue est construite à l'aide de la classe AlertDialog.
Private void openNewGameDialog() ( new AlertDialog.Builder(this).setTitle(R.string.new_game_title).setItems(R.array.difficulty, new DialogInterface.OnClickListener() ( public void onClick(DialogInterface dialoginterface, int i) ( startGame (i); ) )).show(); )
Veuillez noter que le contenu de la boîte de dialogue (un ensemble de boutons) est construit à partir d'un tableau de chaînes R.array.difficulty. Un gestionnaire de clic de bouton de dialogue est immédiatement attribué, qui, en fonction du numéro du bouton enfoncé, démarre un nouveau jeu avec un niveau de difficulté donné en appelant la méthode startGame.
Arts graphiques
La classe Game est responsable de la logique du jeu. Ici, les tâches sont chargées et les conditions gagnantes sont vérifiées. La classe Game est une Activity, mais l'interface n'est pas décrite en XML, mais est créée par code. La méthode onCreate crée une vue :
PuzzleView = nouveau PuzzleView(ce);
setContentView(puzzleView);
puzzleView.requestFocus();
PazzleView est une classe dérivée de View, elle dessine le terrain de jeu et traite les événements tactiles à l'écran (méthode onTouchEvent) et les pressions sur les touches (méthode onKeyDown).
Regardons le processus de dessin sous Android. Pour dessiner, vous devez surcharger la méthode onDraw. La méthode reçoit l'objet Canvas à travers lequel le dessin est effectué. Pour définir les couleurs, des objets de la classe Paint sont créés. La couleur est spécifiée au format ARGB. Il est préférable de stocker la couleur sous forme de ressources (fichier colors.xml). Paint n'est pas seulement une classe permettant de stocker des informations sur les couleurs. Par exemple, lorsque vous dessinez du texte, il contient des informations sur la méthode d'ombrage, la police et l'alignement du texte.
Canvas contient un ensemble de méthodes pour dessiner des graphiques (drawRect, drawLine, drawPath, drawText et autres).
Pour optimiser les graphiques, il est préférable de s'abstenir de créer des objets et des calculs inutiles à l'intérieur de la méthode onDraw (l'exemple considéré d'implémentation graphique n'est pas optimal).
Musique
La classe MediaPlayer est utilisée pour lire de la musique. La musique du jeu a été ajoutée aux ressources. Il vous suffit de copier les fichiers nécessaires dans le dossier /res/raw (formats WAV, AAC, MP3, WMA, AMR, OGG, MIDI).
Vous devez d'abord créer une instance de la classe MediaPlayer :
mp = MediaPlayer.create (contexte, ressource);
ici, le contexte est généralement la classe qui initie le lancement de la musique, la ressource est l'identifiant de la ressource contenant la musique. Pour contrôler la lecture, utilisez les méthodes de démarrage, d'arrêt et de relâchement.
Dans le jeu, la musique est jouée dans le menu principal (lancé depuis la classe Sudoku) et dans le gameplay (lancé depuis la classe Game). La classe Music a été créée pour contrôler la lecture. La classe contient une instance statique de MediaPlayer, ce qui élimine le besoin de créer un projet distinct pour chaque lancement de la ressource audio.
Dans les classes Sudoku et Game, les méthodes onResume et onPause sont remplacées, dans lesquelles la musique démarre au démarrage de l'activité et s'arrête lorsqu'elle est désactivée.
conclusions
L'exemple évoqué dans l'article n'est pas trop compliqué, ce qui permet de le comprendre sans trop d'effort. En même temps, il aborde divers aspects du développement Android.
P.S. Un grand merci à l'utilisateur
Dans toute entreprise, le plus difficile est le début. Il est souvent difficile de se remettre dans son contexte, c'est ce que j'ai rencontré lorsque j'ai décidé de développer ma première application Android. Cet article s’adresse à ceux qui veulent commencer, mais ne savent pas par où.
L'article couvrira l'ensemble du cycle de développement d'applications. Ensemble, nous allons écrire un simple jeu de Tic-Tac-Toe avec un seul écran (sous Android OS, cela s'appelle Activity).
Le manque d’expérience en développement Java ne devrait pas être un obstacle à la maîtrise d’Android. Ainsi, les exemples n'utiliseront pas de constructions spécifiques à Java (ou seront minimisés autant que possible). Si vous écrivez, par exemple, PHP et connaissez les principes fondamentaux du développement logiciel, cet article vous sera très utile. À mon tour, comme je ne suis pas un expert en développement Java, on peut supposer que le code source ne peut pas prétendre au label « meilleures pratiques pour le développement Java ».
Installation des programmes et utilitaires nécessaires
Je vais lister les outils nécessaires. Il y en a 3 :
- IDE avec prise en charge du développement Android :
- Plugin Eclipse + ADT ;
- Édition communautaire IntelliJ IDEA ;
- Plugin Netbeans + nbandroid ;
Les utilitaires sont installés dans l'ordre spécifié ci-dessus. Cela ne sert à rien d’installer tous les IDE répertoriés (sauf si vous avez des difficultés à choisir le bon). J'utilise IntelliJ IDEA Community Edition, l'un des IDE pour Java les plus avancés disponibles aujourd'hui.
Démarrer un appareil virtuel
Après avoir lancé AVD Manager et installé des packages supplémentaires (SDK de différentes versions), vous pouvez commencer à créer un périphérique virtuel avec les paramètres nécessaires. Comprendre l'interface ne devrait pas être difficile.Liste des périphériques
Créer un projet
J'ai toujours hâte de me mettre au travail, en minimisant les activités préparatoires, qui incluent la création d'un projet dans l'IDE, surtout lorsque le projet est éducatif et n'a pas l'intention d'être produit.Donc, Fichier->Nouveau projet :
En appuyant sur le bouton F6, le projet sera assemblé, compilé et lancé sur l'appareil virtuel.
Structure du projet
La capture d'écran précédente montre la structure du projet. Puisque dans cet article nous poursuivons des objectifs purement pratiques, nous nous concentrerons uniquement sur les dossiers que nous utiliserons dans le processus de travail. Il s'agit des répertoires suivants : génération, rés Et src.Dans le dossier génération certains fichiers sont générés automatiquement lors de la construction du projet. Vous ne pouvez pas les modifier manuellement.
Le dossier res est destiné à stocker des ressources telles que des images, des textes (y compris des traductions), des valeurs par défaut, des mises en page.
src- c'est le dossier dans lequel se déroulera l'essentiel du travail, car ici sont stockés les fichiers avec le code source de notre programme.
Premières lignes
Dès la création de l'Activité (écran de l'application), la méthode onCreate() est appelée. L'EDI l'a rempli de 2 lignes :
super.onCreate(savedInstanceState); setContentView(R.layout.main);
La méthode setContentView (équivalente à this.setContentView) définit la disposition XML de l'écran actuel. Dans ce qui suit, nous appellerons les layouts XML « layout » et les écrans « Activity ». La présentation dans l'application sera la suivante :
TableLayout est idéal pour cette application. L’identifiant peut être attribué à n’importe quelle ressource. Dans ce cas, TableLayout se voit attribuer id = main_l. En utilisant la méthode findViewById(), vous pouvez accéder à la vue :
mise en page TableLayout privée ; // il s'agit d'une propriété de la classe KrestikinolikiActivity public void onCreate(Bundle savingInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.main); layout = (TableLayout) findViewById(R.id.main_l); buildGameField( ); )
Nous devons maintenant implémenter la méthode buildGameField(). Pour ce faire, vous devez générer un champ sous forme de matrice. Cela sera fait par la classe Game. Vous devez d’abord créer une classe Square pour les cellules et une classe Player dont les objets rempliront ces cellules.
Carré.java
package com.exemple; public class Square ( private Player player = null; public void fill(Player player) ( this.player = player; ) public boolean isFilled() ( if (player != null) ( return true; ) return false; ) public Player getPlayer () (retourner le joueur ; ) )Joueur.java
package com.exemple; public class Player (private String name; public Player(String name) ( this.name = name; ) public CharSequence getName() ( return (CharSequence) name; ) )Toutes les classes de notre application se trouvent dans le dossier src.
Jeu.java
package com.exemple; public class Game ( /** * field */ private Square field; /** * Constructor * */ public Game() ( field = new Square; squareCount = 0; // remplissant le champ pour (int i = 0, l = champ.longueur;iInitialisation du jeu dans le constructeur KrestikinolikiActivity.
public KrestikinolikiActivity() ( game = new Game(); game.start(); // sera implémenté plus tard)
La méthode buildGameField() de la classe KrestikinolikiActivity. Il ajoute dynamiquement des lignes et des colonnes au tableau (champ de jeu) :
boutons de bouton privés = nouveau bouton ; //(....) private void buildGameField() ( Square field = game.getField(); for (int i = 0, lenI = field.length; i
La ligne 8 crée un objet qui implémente l'interface View.OnClickListener. Créons une classe Listener imbriquée. Il ne sera visible que depuis KrestikinolikiActivity.
public class Listener implémente View.OnClickListener ( private int x = 0; private int y = 0; public Listener(int x, int y) ( this.x = x; this.y = y; ) public void onClick(View view) ( Bouton bouton = vue (Bouton); ) )
Reste à mettre en œuvre la logique du jeu.
public class Game ( /** * joueurs */ joueurs joueurs privés; /** * champ */ champ carré privé; /** * le jeu a-t-il commencé ? */ private boolean démarré ; /** * joueur actuel */ privé Joueur actifPlayer; /** * Compte le nombre de cellules remplies */ private int rempli; /** * Total de cellules */ private int squareCount; /** * Constructeur * */ public Game() ( field = new Square; squareCount = 0; // remplissant le champ pour (int i = 0, l = field.length; i
Détermination du gagnant
K.O. suggère que le gagnant du tic-tac-toe est celui qui aligne X ou O sur une ligne égale à la longueur du terrain verticalement, horizontalement ou en diagonale. La première pensée qui me vient à l’esprit est d’écrire des méthodes pour chaque cas. Je pense que le modèle de chaîne de responsabilité fonctionnerait bien dans ce cas. Définissons l'interfacepackage com.exemple; interface publique WinnerCheckerInterface ( public Player checkWinner(); )
Puisque le jeu a la responsabilité de déterminer le gagnant, il implémente cette interface. Il est temps de créer des « juges de lignes » virtuels, chacun vérifiant son camp. Tous implémentent l’interface WinnerCheckerInterface.
WinnerCheckerHorizontal.java
package com.exemple; public class WinnerCheckerHorizontal implémente WinnerCheckerInterface (private Game game; public WinnerCheckerHorizontal(Game game) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer; Player lastPlayer = null; for (int i = 0, len = champ.longueur ; iWinnerCheckerVertical.java
package com.exemple; public class WinnerCheckerVertical implémente WinnerCheckerInterface ( jeu privé; public WinnerCheckerVertical (jeu) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer; Player lastPlayer = null; for (int i = 0, len = champ.longueur ; iWinnerCheckerDiagonalLeft.java
package com.exemple; public class WinnerCheckerDiagonalLeft implémente WinnerCheckerInterface ( jeu privé ; public WinnerCheckerDiagonalLeft (jeu) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer ; Player lastPlayer = null ; int successCounter = 1 ; pour (int i = 0, len = field.length ; iWinnerCheckerDiagonalRight.java
package com.exemple; classe publique WinnerCheckerDiagonalRight implémente WinnerCheckerInterface ( jeu privé ; public WinnerCheckerDiagonalRight (jeu) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer ; Player lastPlayer = null ; int successCounter = 1 ; pour (int i = 0, len = field.length ; iInitialisons-les dans le constructeur Game :
//(....) /** * "Juges" =). Après chaque coup, ils vérifieront * pour voir s'il y a un gagnant */privé WinnerCheckerInterface gagnantCheckers ; //(....) public Game() ( //(....) gagnantCheckers = nouveau WinnerCheckerInterface; gagnantCheckers = nouveau WinnerCheckerHorizontal(this); gagnantCheckers = nouveau WinnerCheckerVertical(this); gagnantCheckers = nouveau WinnerCheckerDiagonalLeft(this); gagnantCheckers = new WinnerCheckerDiagonalRight(this); //(....) )
Implémentation de checkWinner() :
public Player checkWinner() ( pour (WinnerCheckerInterface winChecker: gagnantCheckers) ( Joueur gagnant = winChecker.checkWinner(); if (winner != null) ( return gagnant; ) ) return null; )
Nous vérifions le gagnant après chaque coup. Ajoutons du code à la méthode onClick() de la classe Listener
public void onClick(Afficher la vue) ( Bouton bouton = (Bouton) vue ; Jeu g = jeu ; Joueur joueur = g.getCurrentActivePlayer(); if (makeTurn(x, y)) ( bouton.setText(player.getName()) ; ) Joueur gagnant = g.checkWinner(); if (winner != null) ( gameOver(winner); ) if (g.isFieldFilled()) ( // si le champ est rempli gameOver(); ) )
La méthode gameOver() est implémentée en 2 variantes :
private void gameOver (Joueur joueur) ( CharSequence text = "Joueur \"" + joueur.getName() + "\" gagné!"; Toast.makeText(this, texte, Toast.LENGTH_SHORT).show(); game.reset (); rafraîchir(); ) private void gameOver() ( CharSequence text = "Draw"; Toast.makeText(this, text, Toast.LENGTH_SHORT).show(); game.reset(); rafraîchir(); )
Pour Java, gameOver(Player player) et gameOver() sont des méthodes différentes. En utilisant le Builder Toast.makeText, vous pouvez créer et afficher rapidement une notification.fresh() met à jour l'état du champ :
private void rafraîchir() ( Square field = game.getField(); for (int i = 0, len = field.length; i
Prêt! J'espère que cet article vous a aidé à vous familiariser avec le monde du développement Android. Merci de votre attention!
Vidéo de la candidature terminée
Le système d'exploitation Android de Google est idéal pour les développeurs qui souhaitent créer des applications pour téléphones mobiles sans avoir à passer à chaque fois par les processus d'approbation complexes d'Apple.
Ce guide vise à vous guider à travers les logiciels et outils nécessaires qui vous aideront à commencer à développer facilement votre propre application.
Peu importe votre niveau de programmation, car si vous parvenez à maîtriser le kit de développement logiciel (SDK) Android, vos applications s'avéreront excellentes. Alors, consultez les ressources ci-dessous pour vous mettre dans le bain.
Kit de développement Java
La première chose dont vous aurez besoin pour commencer à développer des applications Java (la base des applications Android) est le Java Development Kit (JDK) d'Oracle, qui peut être téléchargé à partir du lien suivant.
Vous avez probablement déjà téléchargé et installé Java Runtime Environment (JRE), qui est nécessaire pour exécuter des applets sur votre ordinateur. Vous devez désinstaller la version JRE actuellement installée sur votre ordinateur au cas où elle entrerait en conflit avec la version JDK que vous téléchargez. Heureusement, la version ci-dessus inclut la dernière et la meilleure version du JRE, qui sera certainement compatible avec le JDK, éliminant ainsi le besoin de le réinstaller.
Téléchargez et exécutez le programme d'installation, assurez-vous que « Outils de développement », « Code source » et « Public JRE » sont inclus dans l'installation dans la fenêtre d'installation manuelle (visible ci-dessous). Cliquez sur « Suivant », lisez les termes du contrat de licence si vous disposez de suffisamment de temps libre et procédez à l'installation.
Bien que la plupart des applications d'environnement de développement intégré (IDE) (nous en reparlerons plus en détail à l'étape suivante) soient livrées avec leur propre compilateur, je vous recommande d'intégrer le compilateur Java nouvellement installé dans la ligne de commande afin de pouvoir l'utiliser à la demande. .
Si vous utilisez Windows, accédez aux Paramètres système à partir du Panneau de configuration et sélectionnez Paramètres système avancés. Sélectionnez ici « Variables d'environnement » et recherchez la variable « Chemin ». Ajoutez un let au fichier en tant que répertoire « bin » avant votre installation Java, comme indiqué dans l'exemple ci-dessous.
Pour vérifier si tout a réussi, utilisez les commandes 'java -version' et 'javac -version'. Vous devriez voir quelque chose comme ce qui suit :
Installation de l'EDI
Les environnements de développement intégrés sont souvent utilisés par les développeurs saisonniers et les débutants qui souhaitent développer des applications. Pour ceux qui ne le savent pas, un IDE est une application qui aide les programmeurs à écrire du code en fournissant un ensemble condensé d'outils tels que des débogueurs, des compilateurs, etc.
Bien qu'il existe de nombreux IDE disponibles sur Internet, nous utiliserons ici le logiciel gratuit Eclipse car Google fournit un plugin pour l'intégrer au SDK Android. Vous pouvez télécharger la version requise d'Eclipse.
Cela peut varier d'un cas à l'autre, mais lorsque j'ai téléchargé la ressource, le logiciel était fourni sous forme d'archive zip contenant un fichier « eclipse.exe » avec lequel vous pouviez démarrer sans aucune installation. Si votre version nécessite une installation, faites-la vous-même, car il n'y a pas d'exigences ou de paramètres particuliers. Lorsque vous le lancerez pour la première fois, le logiciel vous demandera de spécifier le « Workbench » où se trouvent vos codes et fichiers associés. Veuillez indiquer un endroit qui vous convient.
Une fois terminé, les éléments suivants vous seront présentés :
Si vous souhaitez vous familiariser un peu avec Eclipse avant de commencer, ouvrez la fenêtre d'aide et parcourez le Guide de l'utilisateur de Workbench. Vous pouvez également consulter le Guide de l'utilisateur de développement ici, qui vous aidera à acquérir les compétences de base de Java si vous n'êtes pas encore familier avec le langage.
Télécharger le SDK Android
Suivez ce lien et cliquez sur « Obtenir le SDK ». Sur la page suivante, vous recevrez un lien pour installer le SDK Android sur votre ordinateur.
Une fois le téléchargement du fichier exécutable terminé, démarrez l'installation. Lorsque vous atteignez la fenêtre ci-dessous, spécifiez le chemin d'accès au répertoire dans lequel vous souhaitez installer, ou souvenez-vous de celui qui est déjà spécifié.
Une fois l'installation terminée, ouvrez Android SDK Manager, puis vous verrez la fenêtre suivante :
Cliquez sur le bouton pour installer tous les packages et ressources requis qui n'étaient pas inclus dans l'installation d'origine.
Installez le plugin Outils de développement Android
Comme indiqué ci-dessus, Google propose un plugin SDK Android spécial pour Eclipse qui peut être ajouté directement à partir de l'EDI.
Dans Eclipse, allez dans « Aide » et sélectionnez « Installer un nouveau logiciel ». Cliquez sur le bouton « Ajouter » et vous serez alors redirigé vers une fenêtre qui vous permettra d'ajouter un référentiel de logiciels en ligne contenant le plugin ADT. Donnez un nom descriptif et entrez l'URL suivante dans le bloc « Localisation » :
- http://dl-ssl.google.com/android/eclipse
Cliquez sur OK'. Sélectionnez le référentiel nouvellement ajouté et cochez la case « Outils de développement ».
Cliquez sur « Suivant » et suivez les étapes pour installer les fichiers du plugin. Une fois terminé, les 2 icônes suivantes devraient apparaître dans votre panneau de configuration Eclipse :
Allez maintenant dans « Fenêtre » et « Préférences », sélectionnez la section « Android » et assurez-vous que l'emplacement du SDK correspond au répertoire du SDK que vous avez spécifié précédemment. En conséquence, vous devriez obtenir ce qui suit :
Vous êtes désormais propriétaire du plugin Android Development Tools.
Configuration d'un émulateur Android
Bien que cela aide, vous n'avez pas besoin d'avoir tous les modèles d'appareils Android sous la main pour créer des applications pour eux, car Google nous fournit un excellent émulateur de son propre système d'exploitation mobile ainsi qu'un SDK. Avant de commencer le développement, il nous est conseillé de configurer le périphérique virtuel Android (AVD) afin que la plateforme de test soit prête à l'avance.
Nous devons maintenant créer un nouveau périphérique virtuel. Cet exemple suppose la création d'un appareil général, mais il existe également des ressources pour les paramètres spécifiques des appareils Android. Sélectionnez « Nouveau » et une fenêtre vide comme celle ci-dessous s'affichera :
- Nom : Si vous souhaitez tester l'application sur les paramètres de plusieurs appareils, vous devrez alors saisir quelque chose de descriptif. D’un autre côté, un nom plus général peut également être utilisé.
- Cible : Il s’agit de la version d’Android que l’émulateur ciblera. Dans la plupart des cas, votre option sera la dernière version d'Android, fournie avec le SDK que vous installez. Cependant, si vous souhaitez tester sur des versions antérieures (ce qui serait tout à fait judicieux étant donné qu'il existe de nombreuses versions et modèles différents), utilisez le gestionnaire de SDK pour installer des versions supplémentaires.
- Carte SD : Indicateur de l'espace de stockage supplémentaire à utiliser dans l'appareil. Par défaut, le périphérique virtuel dispose de 194 Mo de mémoire « interne » et d'une carte SD, vous devrez donc spécifier manuellement la quantité d'espace disque requise.
- Skin : vous pouvez utiliser cette option pour définir l'apparence et les configurations d'un appareil spécifique (HTC One X, par exemple). Mais dans notre cas, nous utilisons la valeur standard.
- Matériel : étant donné qu'il existe des différences matérielles significatives entre les appareils Android physiques, vous pouvez utiliser cette option pour ajouter tout matériel qui sera utilisé par votre application.
Une fois terminé, la fenêtre AVD Manager devrait inclure votre appareil nouvellement créé. Vous pouvez cliquer sur « Démarrer » pour démarrer cet appareil, sachez simplement que le premier démarrage peut prendre un certain temps.
Votre premier projet Android
Maintenant que vous avez équipé votre ordinateur de toutes les applications et plugins nécessaires, vous pouvez commencer à développer du code. Mais il faut d’abord préparer les dossiers du projet.
Pour commencer, allez dans « Fichier », « Nouveau », « Projet » et ouvrez l'onglet Android. Sélectionnez-y « Projet d'application Android » et la fenêtre suivante s'ouvrira devant vous :
Vous pouvez utiliser les menus déroulants à côté de chaque champ pour sélectionner la valeur appropriée. La principale chose à considérer est le « Nom de l’application », qui est responsable du nom de notre application lors de l’installation, ainsi que le « SDK minimum requis », avec lequel vous indiquez la première version d’Android qui prend en charge votre application.
Cliquez sur « Suivant » pour continuer et définissez une icône exécutable qui sera le visage de votre application. Le menu suivant vous demandera de créer une « Activité » pour votre application.
Il s'agit de l'action ou de la vue avec laquelle l'utilisateur interagira. La chose la plus logique à faire est donc de diviser votre application en activités en fonction des fenêtres que l'utilisateur verra et des fonctionnalités qui seront disponibles dans chacune d'elles. Ainsi, si vous créez, par exemple, un simple programme "Hello World", vous n'avez besoin que d'une seule fenêtre active qui représente le texte, et tous les paramètres d'interface sont extraits des fichiers de ressources créés par le SDK.
Lorsque vous avez choisi ces fenêtres, cliquez sur « Terminer ». Eclipse rassemblera tous les fichiers nécessaires à l'application dans lesquels vous écrirez du code et/ou modifierez les paramètres pour spécifier les paramètres de votre programme.
Et c'est tout! Tout est prêt pour assembler l'application terminée. Vous pouvez trouver des didacticiels complets sur Google sur la façon de développer des applications Android (pour ceux qui ont une expérience en programmation). Quiconque souhaite se lancer dans la programmation Java doit également d’abord lire des didacticiels comme celui fourni par Oracle.
Vous avez donc décidé de devenir développeur d’applications mobiles pour le système d’exploitation Android. C'est une excellente solution, mais sans certaines connaissances, cela ne fonctionnera pas. Au minimum, vous devez apprendre la programmation. Il existe plusieurs langages de programmation et vous devrez choisir par lequel commencer. Il y a une différence entre eux, et elle n’est peut-être pas très facile à comprendre.
Voici les langages de programmation qu’un futur développeur Android pourrait envisager :
- Java est le langage de développement officiel pour Android et est pris en charge par l'environnement de développement de Google. Ce n'est peut-être pas si facile à apprendre.
- Kotlin – Cette langue a été introduite comme deuxième langue officiellement prise en charge. Il est similaire à Java à bien des égards, mais il est plus facile de démarrer.
- C/C++ – Android Studio prend en charge le C++. Ce langage est encore plus complexe, mais il est activement utilisé dans le développement de jeux.
- C# – ce langage peut plaire aux débutants. Il est pris en charge par les environnements de développement Unity et Xamarin. Ils offrent des avantages lors du développement de jeux et de produits pour différentes plateformes.
- BASIC – Ce langage est pris en charge par l'IDE B4A, qui est un outil simple mais puissant.
- Corona/LUA – L'environnement LUA est idéal pour développer des produits multiplateformes. Il simplifie grandement la création d’applications et donne accès à des bibliothèques natives.
- PhoneGap (HTML, CSS, JavaScript) – Cette option convient à ceux qui savent créer des pages Web interactives. Avec PhoneGap, vous pouvez créer des applications multiplateformes de la même manière.
Examinons maintenant ces options plus en détail.
Java
Le langage de programmation Java est le premier qui vient à l’esprit lorsqu’on parle de développement Android. Java a été lancé par Sun Microsystems en 1995. Il est utilisé pour différents types d’applications. En ce qui concerne les applications Android, Java est le meilleur choix pour ceux qui souhaitent se lancer tête première dans le développement Android. Cependant, ce n’est pas la meilleure langue pour un débutant. Vous rencontrerez certainement des difficultés. Si vous êtes débutant, que vous souhaitez créer un jeu ou commencer à apprendre, mais que vous n'avez pas encore décidé quel type de résultat vous souhaitez obtenir, vous voudrez peut-être commencer par quelque chose de plus simple.
Kotlin
Kotlin, tout comme Java, est idéal pour le développement d'applications Android. La différence est que Kotlin est plus facile pour les débutants, mais pas encore plus facile que de nombreuses autres options. Cela vaut le détour car le langage est jeune et vous pouvez travailler avec lui dans Android Studio, ce qui est un gros plus.
C/C++
Ce n'est pas le meilleur choix pour créer des applications simples. Vous pouvez travailler avec le langage dans Android Studio à l'aide du NDK Android, mais contrairement à Java et Kotlin, il ne s'exécute pas sur la machine virtuelle Java. Cependant, il fonctionne nativement sur l'appareil, ce qui peut vous offrir plus d'options de mémoire. Vous pouvez obtenir de meilleures performances dans les jeux 3D avec. Si tel est votre choix, préparez-vous aux difficultés. Vous feriez peut-être mieux d'utiliser un moteur de jeu prêt à l'emploi pour créer vos jeux.
C#
C# est une version plus simple de C et C++ développée par Microsoft. Avec ce langage, vous n'avez pas à vous soucier de la gestion de la mémoire, tout comme avec Java. Cependant, C# est plus moderne et plus propre que Java. C# et Unity seront très utiles et faciles à développer des jeux. Pour le développement d’applications, l’environnement Unity n’est pas très bon. C# est un excellent choix, mais cela limitera vos options si vous souhaitez devenir un développeur Android professionnel.
BASIQUE
Cette langue est la meilleure option pour un débutant. Vous pourrez l'utiliser dans l'environnement de développement B4A. Cette combinaison n'est pas idéale pour créer des jeux, mais elle est idéale pour apprendre à développer. Vous pouvez apprendre beaucoup de nouvelles choses sans trop de travail et créer de bonnes applications. Cependant, pour toutes ces joies, vous devrez payer en argent. Vous apprendrez quelque chose de nouveau, mais vous ne deviendrez pas un professionnel si vous savez seulement programmer en BASIC.
Couronne
Corona en conjonction avec LUA vous permettra de développer non seulement pour Android, mais c'est beaucoup plus facile que de commencer à apprendre Java. Vous l'aimerez et serez satisfait des résultats, mais pour développer vos compétences, vous devrez apprendre autre chose. Comme avec BASIC, il n’y a aucun moyen de devenir professionnel.
Espace téléphonique
La dernière option convient à ceux qui maîtrisent le développement Web et peuvent créer un site Web interactif en utilisant HTML, CSS et JavaScript. PhoneGap vous permettra de créer une application en utilisant les mêmes outils. Cette option a très peu à voir avec le développement Android, mais elle convient si vous avez des objectifs spécifiques et que vous n'envisagez pas de développer pour Android à l'avenir.
Il existe de nombreuses options. Nous sommes convaincus que vous saurez faire le bon choix.
Basé sur l'autorité Android