Composition d’une application Android
Une application Android est composée de plusieurs activités. Chaque activité gère un écran d’interaction avec l’utilisateur et est définie par une classe Java.
Une application complexe peut également contenir :
- des services : ce sont des processus qui tournent en arrière-plan ;
- des fournisseurs de contenu : ils représentent une sorte de base de données ;
- des récepteurs d’annonces : pour gérer des événements globaux envoyés par le système à toutes les applications.
Déclaration d’une application
Le fichier AndroidManifest.xml déclare les éléments d’une application, avec un point devant le nom des activités.
La balise <application> est la seule branche sous la racine <manifest>, et ses enfants sont des balises <activity>.
Exemple de structure :
<?xml version="1.0" encoding="utf-8"?>
<manifest ...>
<application android:icon="@drawable/app_icon.png" ...>
<activity android:name=".MainActivity" android:label="@string/main" ... />
<activity android:name=".EditActivity" android:label="@string/edit" ... />
...
</application>
</manifest>
Sécurité des applications Android
Chaque application est associée à un UID (compte utilisateur Unix) unique dans le système. Ce compte protège les applications les unes des autres.
L’UID peut être défini dans le fichier AndroidManifest.xml via l’attribut android:sharedUserId.
Définir cet attribut avec une chaîne identique à une autre application et signer les deux applications avec le même certificat permet à l’une d’accéder à l’autre.
Exemple de syntaxe :
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="string"
android:sharedUserId="ma.ensa.myapplication1"
android:sharedUserLabel="string resource"
android:versionCode="integer"
android:versionName="string"
android:installLocation=["auto" | "internalOnly" | "preferExternal"]>
...
</manifest>
Autorisation d’une application
Une application doit déclarer les autorisations nécessaires pour fonctionner, comme l’accès à Internet, à la caméra, au carnet d’adresses, au GPS, etc.
Ces autorisations sont ajoutées dans le fichier AndroidManifest.xml via des balises <uses-permission>.
Exemple de déclaration :
<?xml version="1.0" encoding="utf-8"?>
<manifest ...>
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CALL_PHONE" />
...
</manifest>
Démarrage d’une application Android
L’une des activités est marquée comme démarrable de l’extérieur via un <intent-filter>.
Ce filtre déclare les conditions de démarrage d’une activité. Par exemple, pour définir une activité comme principale :
<activity android:name=".MainActivity" ...>
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
Principe des Intents en Android
Les Intents permettent de gérer l’envoi et la réception de messages pour faire coopérer les applications.
Ils servent à déléguer :
- une autre activité de la même application ;
- une action à un autre composant ;
- ou une autre application.
Un objet Intent peut contenir :
- le nom du composant ciblé (facultatif) ;
- l’action à réaliser (chaîne de caractères) ;
- les données (contenu MIME et URI) ;
- des données supplémentaires sous forme de paires clé/valeur ;
- une catégorie pour cibler un type d’application ;
- des drapeaux (informations supplémentaires).
Les Intents peuvent être informatifs ou déclencher une nouvelle activité.
URI : Uniform Resource Identifier (identifiant de ressource uniforme).
URL : Uniform Resource Locator (localisateur de ressource uniforme).
Lancement d’une activité par programme
Pour lancer une activité depuis une autre, on utilise l’instruction startActivity.
Par exemple, si une application contient deux activités : Activ1 et Activ2, la première peut lancer la seconde via :
Intent intent = new Intent(Activ1.this, Activ2.class); startActivity(intent);
Dans certains cas, il ne faut pas utiliser this mais getApplicationContext() si l’objet manipulant l’Intent n’hérite pas de Context.
Ce code est utilisé lorsqu’un bouton, un menu ou autre élément est cliqué. Les deux activités doivent être déclarées dans AndroidManifest.xml.
Lancement d’une application Android externe
Pour déléguer une action à une autre application, on fournit au constructeur de l’Intent les données et l’URI cible. Le système Android recherche alors une application capable de traiter cet Intent.
Exemple pour ouvrir un navigateur sur une URL spécifique :
String url = "https://www.example.com"; Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)); startActivity(intent);
Pour émettre un appel téléphonique, il faut ajouter la permission android.permission.CALL_PHONE dans le manifeste.
Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:066123456"));
startActivity(intent);
Fonctionnement d’une application Android
Au démarrage, Android lance l’activité marquée avec action=MAIN et catégorie=LAUNCHER dans le fichier AndroidManifest.xml.
Les activités fonctionnent comme une pile : une nouvelle activité s’affiche devant les autres. Deux cas sont possibles :
- L’activité précédente se termine et n’est pas rappelée (exemple : une activité de connexion lance l’activité principale et se termine).
- L’activité précédente attend la fin de la nouvelle pour récupérer un résultat (exemple : une activité lance une autre activité pour modifier des informations et attend un retour).
Lancement sans attente d’une activité
Pour lancer une activité sans attendre son retour, on utilise startActivity.
Exemple :
Intent intent = new Intent(Activ1.this, Activ2.class); startActivity(intent);
Si l’activité précédente doit se terminer après le lancement de la nouvelle, on ajoute finish().
Intent intent = new Intent(Activ1.this, Activ2.class); startActivity(intent); finish();
Transport et extraction d’informations dans un Intent
Les Intents permettent de transporter des données entre activités via les extras.
Pour placer des données dans un Intent, on utilise la méthode putExtra(nom, valeur).
Pour récupérer les données d’un Intent, on utilise :
getIntent()pour obtenir l’Intent qui a démarré l’activité ;getTypeExtra(nom, valeur par défaut)pour récupérer la valeur associée à un nom.
Exemple avec un Bundle :
Intent intent = getIntent();
String name = intent.getStringExtra("nom");
Integer age = intent.getIntExtra("age", -1);
boolean present = intent.getBooleanExtra("presence", false);
Lancement avec attente de résultat
Pour lancer une activité et attendre un résultat, on utilise startActivityForResult avec un code d’appel RequestCode.
Ce code identifie l’activité lancée pour distinguer les réponses au retour.
Exemple :
private static final int APPEL_ACTIV2 = 1; Intent intent = new Intent(Activ1.this, Activ2.class); startActivityForResult(intent, APPEL_ACTIV2);
Gestion du résultat avec onActivityResult
La méthode onActivityResult est appelée lorsqu’une activité enfant retourne un résultat.
Elle prend trois paramètres :
requestCode: le code d’appel destartActivityForResult;resultCode:RESULT_CANCELEDouRESULT_OK;data: les données fournies par l’activité enfant.
Exemple de gestion du résultat :
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == Activity.RESULT_CANCELED) return;
switch (requestCode) {
case APPEL_ACTIV2:
String message = data.getStringExtra("Message");
Toast.makeText(this, "Code de requête récupéré", Toast.LENGTH_LONG).show();
break;
}
}
L’activité enfant envoie un résultat via setResult(resultCode, data) avant de se terminer.
Exemple de transport d’informations entre activités
Voici un exemple complet où une activité envoie une couleur à une autre activité et affiche un message.
public class MainActivity extends AppCompatActivity {
LinearLayout containerTwo;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main2);
containerTwo = (LinearLayout) findViewById(R.id.containerTwo);
Intent intent = getIntent();
String color = intent.getStringExtra("color");
changeBackground(color);
}
public void openActivityOne(View v) {
Intent intent = new Intent(MainActivity.this, Main2Activity.class);
startActivity(intent);
}
public void changeBackground(String color) {
if (color.equals("red")) {
containerTwo.setBackgroundColor(Color.RED);
} else if (color.equals("green")) {
containerTwo.setBackgroundColor(Color.GREEN);
} else if (color.equals("blue")) {
containerTwo.setBackgroundColor(Color.BLUE);
}
}
}
public class Main2Activity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void onClick(View v) {
Intent intent = new Intent();
intent.putExtra("color", "red");
setResult(RESULT_OK, intent);
finish();
}
}
Validation de champs avec les expressions régulières
Les expressions régulières permettent de valider des formats spécifiques, comme une adresse email.
Exemple de validation d’un email :
Pattern p = Pattern.compile(".+@.+\\.[a-z]+");
Matcher m = p.matcher(loginTxt);
if (!m.matches()) {
Toast.makeText(getApplicationContext(), "Erreur : Email invalide", Toast.LENGTH_LONG).show();
return;
}
On vérifie également que les champs ne sont pas vides :
if (loginTxt.equals("") || passTxt.equals("")) {
Toast.makeText(MainActivity.this, "Champs vides", Toast.LENGTH_LONG).show();
return;
}
FAQ
Qu’est-ce qu’un Intent en Android ?
Un Intent est un message qui permet de communiquer entre les composants d’une application Android (activités, services, etc.) ou avec d’autres applications. Il sert à déclencher une action ou à transmettre des données.
Comment déclarer une activité principale dans AndroidManifest.xml ?
On utilise un <intent-filter> avec les balises <action android:name="android.intent.action.MAIN"> et <category android:name="android.intent.category.LAUNCHER">.
Quelle méthode utiliser pour attendre un résultat d’une activité enfant ?
On utilise startActivityForResult avec un code d’appel unique et on récupère le résultat dans la méthode onActivityResult.