>

TP 1 : Applications pour Android (Les Activités)

Exercice 1

1. Installation des outilles de développement d'applications pour android:

Pour installer android SDK et le pluging ADT sous Eclipse, RDV sur
http://developer.android.com/sdk/index.htm .
Télécharger tout en cliquant sur "Download the SDK ADT Bundle for Windows".
Avec un seul téléchargement, l'ensemble ADT comprend tout ce dont vous avez besoin
pour commencer à développer des applications.
Je vous conseil d'installer android 2.2 (API 8) (SDK platform 2.2) et l'utiliser comme version
minimale. Cette version est un peu légère lors de l'execution de lʼémulation.
Pour l'installer lancer SDK Manager (que vous trouvrez sur le répertoire d'installation) est
choisissez android 2.2 (API 8) puis cliquez sur install (Accepter la licence).
2. Changer l'apparence de l'émulateur

Sur la page http://jsharkey.org/blog/2008/10/10/leveraging-the-android-

emulator/ ou télécharger directement
http://jsharkey.org/downloads/G1.zip

Décompresser le dossier G1.zip dans le dossier dʼinstallation dʼandroid : …

\Android\android-sdk\platforms\android-8\skins
Créer un nouveau AVD par Eclipse nommé "emuG1"

Une boîte de dialogue qui nous est déjà familière apparaît: Android SDK and AVD
Manager.
Là vous trouverez la rubrique virtual devices, dans laquelle nous allons ajouter notre
fameux émulateur android.
Cliquez donc sur New...

Translate
Dans la nouvelle boîte de dialogue qui apparaît par la suite tappez le nom de
l'émulateur et choisir la configuration suivante par exemple:

Puis cliquer sur OK

Editer le fichier ". android/avd/emuG1.avd/config.ini" en modiffiant les deux
propriétés suivantes skin.name et skin.path
skin.name=G1
skin.path=platforms\android-8\skins\
Sauvegarder et lancer lʼémulateur
CTRL + F11 pour rotation de l'avd
Exercice 2

Solution: Vous pouvez récupérer le code source du projet ici 

L'objectif de cette exercice est de se familiariser avec les déférentes façons de création
dʼactivité dans une application Android, et comment faire interagir (ou communiquer) les
activités d'une application entre aux.
Définition :
Une activité est un composant d'application (classe qui étende la classe Activity) qui
fournit une IHM avec lequel l'utilisateur peut interagir afin de faire quelque chose.
Nous allons donc créer :
une activité principale
une sous activité en utilisant la même classe que celle de l'activité principale
une sous activité en utilisant une nouvelle classe (héritant de la classe Activity)
des activités planifiées en utilisant les Alarmes du système d'android (AlarmManager)
et récepteur de diffusion (BroadcastReciever).
des activités systèmes en répondant à des intentions implicites (implicit intents). 

1. Commençons nous par créer l'activité principale

Lancer l'IDE Eclipse

Créer un projet application android nommé : ActivitiesDemo en choisissant android
2.2 comme version de compatibilité de notre application (next --> next --> finish)
Ouvrir le fichier res/values/string.xml
Changer la valeur du string hello_world en "Bonjour les activités!" cette valeur
constante est identifiée par hello_world et elle est utilisée dans le fichier
res/layout/activity_main.xml
<TextView android:text="@string/hello_world"
Lancer votre application (selectionner le projet --> run as android application)
Mise en œuvre des rappels (callbacks) du cycle de vie d'une activité

Notre activité principale est définie par la classe MainActivity. Ouvrir le fichier
MainActivity.java (package com.example.activitiesdemo).
Ajouter les méthodes du cycle de vie de l'activité présentées dans la figure suivante :
Dans chaque méthode ( onStart(), onPause(), ...) ajouter la ligne: log.i("", "on xxx
method!");  xxx est le nom de la méthode.
Penser à utiliser le raccourcie Elcipse  "onStart + ctrl" pour la méthode onStart() par
exemple:
  @Override
protected void onStart() {
Log.i("", "On Start method!");
super.onStart();
}

re-lancer votre application et voir les sorties dans LogCat (Pour visualiser LogCat : eclipse
--> window --> show view --> other --> android --> LogCat).
L'ajout des vues dans une activité

Editer le fichier res/layout/activity_main.xml en mode Graphical Layout

S'assurer que le layout utiliser est RelativeLayout
Insérer un champs de texte (EditText) et sept boutons (Button) avec les IDs
repectivement bntWhatEdited, btnSelfSubActivite, btnGotoGoogle, btnCallUrgence, ,
btnWifiSetting, btnAppSetting,et btnPlanifActivity. Les textes de ces boutons sont
respectivement Qoui?, "Lancer sous activité par la même classe", www.google.com",
"Appel d'urgence", "Paramètres wifi",   "Paramètres des applications" et "Activités
planifiées".
Tous les vues ont les 2 prepriété suivantes :
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
Sélectionner chacune de ces composants puis cliquer sur le bouton droit (pour
avoir le menu contextuel.
 Choisir Layout width --> match_parent et Layout height -->
"wrap_content".

Le code XML obtenu dans le fichier res/layout/activity_main.xml

re-lancer votre application (le clique sur un bouton n'a pas d'effet, il faut maintenant
configurer les écouteurs d'événements).
Les événements ( http://developer.android.com/guide/topics/ui/ui-events.html )

Pour afficher un message contienant le texte saisi dans le champs de lors du clique sur le
bouton bntWhatEdited, ajouter un écuteur d'événement clique (OnClickListener) au bouton
btnWhatEdited, vous devez tous d'abord récupérer une référence à cet composant par
l'appel de la méthode findById(), puis déclarer l'écouteur. Dans cette exemple nous allons
choisir l'activité elle même comme écouteur. Donc la classe MainActivity doit implementer
l'interface OnClickListener

 public class MainActivity extends Activity implements OnClickListener {

}

Modifier donc le corps de la méthode onCreate():

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        editText = (EditText) findViewById(R.id.editText1);
        ((Button)findViewById(R.id.btnQoui)).setOnClickListener(this);
}
 public void onClick(View v) {
        Intent intent ;
        switch (v.getId()) {
        case R.id.btnQoui:
            Toast.makeText(this, editText.getText(), Toast.LENGTH_SHORT).show();
            break;
        default:
            break;
        }
}

Toast : Un toast fournit des informations simples sur une opération dans une petite fenêtre
( http://developer.android.com/guide/topics/ui/notifiers/toasts.html )

re-lancer  et tester votre application.

2. Une sous activité en utilisant la même classe que de l'activité principale

Rappel sur les Intentions:

L'intention (Intent) est une description abstraite d'une opération à effectuer. Il peut être utilisé pour:
lancer une activité avec startActivity(Intent),
inclure des données et l'envoyer aux recepteur de diffusion intéressés (BroadcastReceiver) avec
broadcastIntent(Intent),
communiquer avec un service de fond en appellant startService(Intent ) ou bindService(Intent, ServiceCon
int) . Voir la doc sur ce lien: http://developer.android.com/reference/android/content/Intent.html
Les intention peuvent être explicites ou implicites :

Explicites : Pour démarrer une activité à lʼaide d'une intention explicite « explicit intent » :
Intent  uneActivite = new Intent (explicitContext, expliciteClasse);
startActivity (uneActivite)
Exemple : lancer l'activité PlanifiedActivities

intent = new Intent(this, PlanifiedActivities.class);  startActivity(intent);

Implicites: Lors d'un routage externe, nous n'indiquons plus la classe à atteindre (intention explicite), m
minimum l'action que nous désirons déclencher et des données (sous forme uri) :
Intent uneActivite = new Intent (action, data);
startActivity (Uneactivite);
Exemple : lancer le navigateur sur l'adresse google
intent = new Intent(Intent.ACTION_VIEW,  Uri.parse("http://www.google.com"));
startActivity(intent);
Transfert de données

Comme nous lʼavons mentionné un « intent » peut contenir des données.  .

Le composant qui créé lʼintention peut lui ajouter des données en invoquant la méthode « putExtra(key, value) »
« intent » peut-être récuppéré par la méthode « getIntent() » et les
données peuvent être récuppérées par la méthothe getExtrats().
Lancer une activité avec récupération d'informations en retour

startActivity(Intent intent) permet seulement de lancer une activité. Cependant, nous aurons aussi besoin de lan
activités et récupérer le résultat de ces activités.
Pour ce faire,  au lieu d'utiliser la startActivity() on utilise la méthode

  startActivityForResult(Intent intent, int requestCode){/ ..}

L'activité qui recevra le résultat (donc celle qui a appelé la méthode startActivityForResult) devant recevoir un ré
devra implémenter la méthode suivante:

 protected void onActivityResult(int requestCode, int resultCode, Intent intent) {...}

Deux principaux codes de retour de l'activité appelée sont:

RESULT_OK: L'activité c'est bien déroulée (signé = -1 ou tous les bits sont positionnés 0xffffffff).
RESULT_CANCELED: Abandon de l'activité (0).
Rien ne vous empêchant de retourner d'autres valeurs (différentes de celles indiqués ci-dessus si possible !) qu
appelante devra être en mesure d'interpréter.
Pour retourner cette valeur, il faudra (obligation !) utiliser la méthode setResult(int code_retour, Intent intent); o
setResult(int resultCode); cette méthode est souvant appelée dans le corps de la méthode finich().
Terminer l'activité appelée

Il reste maintenant à mettre fin à notre activité appelée pour retourner à notre activité appelante. Il suffit d'utilis
méthode finish(); d'une activité.
Exemple :

 @Override
    public void finish() {
        setResult(RESULT_OK, new Intent().putExtra("Edited", editText.getText()));
        super.finish();
    }

        
Cette phase est importante, car c'est elle qui permettra de déclencher la méthode protected
void onActivityResult(int requestCode, int resultCode, Intent intent) de l'activité appelante
qui pourra alors lire les informations retournées par l'activité appelée.

 @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
         if(requestCode==99 && resultCode== RESULT_OK){
             editText.setText(data.getExtras().getCharSequence("Edited"));
         }
        super.onActivityResult(requestCode, resultCode, data);
    }

Travail à faire:
 
Configurer l'écouteur de l'événement de clique du  bouton btnSelfSubActivity comme ceci :
 ajouter la ligne suivante dans le corps de la méthode onCreate()

 ((Button)findViewById(R.id.btnSelfSubActivite)).setOnClickListener(this);

Dans la méthode onClick(View v) ajouter le cas suivant:

 case R.id.btnSelfSubActivite :
              intent = new Intent(this, getClass());
               intent.putExtra("self-sub-activity", "yet");
              startActivityForResult(intent, 99);
              break;

Ajouter les codes des méthodes finish() et onActivityResult() vues précédemment.

Re-lancer  et tester votre application.
Pour bien différencié la sous activité ajouter le code suiavant dans la méthode
onCreate()
 if(this.getIntent().hasExtra("self-sub-activity")){
            Toast.makeText(this, "self-sub-activity", Toast.LENGTH_SHORT).show();
}

3. Une sous activité en utilisant une nouvelle classe (héritant la classe

Activity)

Créer une nouvelle Activité PlanifiedActivities (Eclipse, new --> android --> activity)
Le clique sur le bouton  btnPlanifActivity  permet de créer et lancer une instance de cette
sous activité. Donc vous devez configurer l'écouteur de l'événement de clique de ce bouton
en ajoutant la ligne  de code suivante dans le corps de la méthode onCreate():

  ((Button)findViewById(R.id.btnPlanifActivity)).setOnClickListener(this);

      
Dans la méthode onClick(View v) ajouter le cas suivant:
 
 case R.id.btnPlanifActivity:
           intent = new Intent(this, PlanifiedActivities.class);
            startActivity(intent);break;

Pour bien différencier cette sous activité de l'activité principale ajouter une valeur string
dans le fichietr res/values/strings.xml
<string name="hello_sub_activity">Bonjour activités planifiées!</string>
Puis modifier le texte pour la vue TextView du fichier res/layout/activity_sub.xml pour
prendre la valeur hello_sub_activity à la place de hello_world.
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_sub_activity" />
Re-lancer votre application et cliquer sur le bouton "Activité Planifiées"

     
   ------
-->

Nous allons y revnir à cette activité pour manipuler les activités planifiées.

4. Activités systèmes en répondant à des intentions implicites (implicit

intents).

Vous allez maintenant utiliser des intention implicite. Iimplanter tous d'abord le code
nécessaire pour enregistrer l'activité principale comme  écouteur de l'événement  Click sur
les ces boutons btnGotoGoogle, btnCallUrgence,  btnWifiSetting, et btnAppSetting. Dans la
méthode onCreate() ajouter :

         ((Button)findViewById(R.id.btnGotoGoogle)).setOnClickListener(this);
        ((Button)findViewById(R.id.btnCallUrgence)).setOnClickListener(this);
        ((Button)findViewById(R.id.btnAppSetting)).setOnClickListener(this);
        ((Button)findViewById(R.id.btnWifiSetting)).setOnClickListener(this);

Dans la méthode onClick(), les intentions implicites seront utilisées avec different actions.
les cas à ajouter au bloque switch sont :

  case R.id.btnGotoGoogle:
            intent = new Intent(Intent.ACTION_VIEW,
Uri.parse("http://www.google.com"));
            startActivity(intent); break;
        case R.id.btnAppSetting:
            intent = new Intent(Settings.ACTION_APPLICATION_SETTINGS );
            startActivity(intent); break;
        case R.id.btnWifiSetting:
            intent = new Intent(Settings.ACTION_WIFI_SETTINGS );
            startActivity(intent); break;
        case R.id.btnCallUrgence:
            intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:112"));
            startActivity(intent); break;

                      

5. Activités planifiées en utilisant les Alarme du système d'android

(AlarmManager) et récepteur de diffusion (BroadcastReciever).
L'objectif de cette partie et de vous monter comme utiliser l'alarme du systeme android et
les recepteur de diffussion d'intention ( AlarmManager, BroadcastReciever, et IntentFilter).
Pour manipuler les activités planifiées, vous allez les créer et les lancer par la sous activité
PlanifiedActivities. Pour ce faire :
Créer trois bouton dans le layout de la sous activité PlanifiedActivities c'à'd dans le fichier
activity_sub.xml ayant comme IDs btnBroadcastViaIntent,
btnDynamicBroadcastRecViaAlarm, et btnXMLStaticBroadcastRecViaAlarm et textes
respectivement "diffusion via Intent", "Activité planifiée (receptin dynamique)", et "Activité
planifiée (receptin statique)".

Interface de l'activité PlanifiedActivities

Re-lancer et tester votre application.

Configurer maintenant la gestion d'événement  en ajoutant implements OnClickListener à la

déclaration de la  classe PlanifiedActivities. En suite ajouter le code suivant dans la méthode
onCreate : 
  
  ((Button) findViewById(R.id.button1)).setOnClickListener(this);
    ((Button) findViewById(R.id.button2)).setOnClickListener(this);
    ((Button) findViewById(R.id.button3)).setOnClickListener(this);

Tous le traitement va être fait dans la méthode onClick qu'on va écrire sous la forme
(n'oublier pas d'utiliser le raccourci eclipse "switch+ctrl")

 @Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btnBroadcastViaIntent: 
// code 1
break; 
case R.id.btnDynamicBroadcastRecViaAlarm: 
// code 2
break;
case R.id.btnXMLStaticBroadcastRecViaAlarm: 
// code 3
break;
} 
}

Maintenant pour le cas de la R.id.btnBroadcastViaIntent (diffusion via Intent" ), nous allons

tous simplement envoyer un « intent » à un composant « BroadcastReceiver » par
sendBroadcast (intent). C'à'd créer un nouveau Intent avec une action par exemple
"ACTION_ALARM", ajouter un extra puis la diffuser par l'invocation de sendBroadcast. Donc
code 1 est le suivant

 intent = new Intent("ACTION_ALARM");

intent.putExtra("param", "Bonjour via Intent");
sendBroadcast(intent);

L'Intent diffusé par sendBroadcast va être intercepté par une instance de la classe abstraite
BroadcastReceiver qui sera enregistrée chez l'activité avec un intent-filter sur l'action
"ACTION_ALARM". Donc le code suivant doit être ajouter à la méthode onCreate de classe
PlanifiedActivities

 receiver = new Receiver();

IntentFilter filter = new IntentFilter("ACTION_ALARM");
registerReceiver(receiver, filter);

Où reciver est un attribut de la classe PlanifiedActivities et Receiver  une classe héritant de

BroadcastReceiver
 
 public class Receiver extends BroadcastReceiver {
@Override
public void onReceive(Context ctx, Intent intent) {
Toast t = Toast.makeText(ctx, intent.getExtras().getString("param"),
Toast.LENGTH_SHORT);
t.show();
} 
}

Re-lancer et tester votre application.

Pour le cas R.id.btnDynamicBroadcastRecViaAlarm (dynamique) nous allons créer et lancer
une action planifier en utilisant le service d'alrme du systeme android (la classe
AlarmManger qui permet d'accéder aux services d'alarme du système). Il vous permet de
planifier votre application à s'exécuter à un certain moment dans l'avenir.Quand une alarme
se déclenche, l'intention qui avait été enregistré pour elle est diffusée par le système, et le
démarrage automatique de l'application cible si elle n'est pas déjà en cours d'exécution).
Dans cette exercice l'activité planifiée s'executra après 3 seconds et affichera un simple
message d'information (Toast). Pour ce faire un attribut alarms de type AlarmManager est
ajouté à la classe PlanifiedActivities. Donc le code 2 est le suivant :

 intent = new Intent("ACTION_ALARM");

intent.putExtra("param", "Bonjour via Alarm");
PendingIntent operation = PendingIntent.getBroadcast(v.getContext(), 0, intent, 0);
alarms.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()+3000, 
operation);

où alarms est un attribut de type AlarmManager initialisé dans la méthode onCreate ,par la
ligne :

 alarms = (AlarmManager) getSystemService(ALARM_SERVICE);

Re-lancer et tester votre application.

Pour le dernier cas R.id.btnXMLStaticBroadcastRecViaAlarm (statique), nous allons déclarer
notre BroadcastReceiver dans le fichier Androidmanifist.XML à lʼintérieur de la balise
application

 <receiver android:name="com.example.activitiesdemo.Receiver">
<intent-filter>
<action android:name="ACTION_ALARM_FILTRED" /> 
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</receiver>

  Le code 3  est le suivant  :

 intent = new Intent("ACTION_ALARM_FILTRED");

intent.putExtra("param", "Bonjour via Alarm (reciever in xml)");
PendingIntent op= PendingIntent.getBroadcast(v.getContext(), 0, intent, 0);
alarms.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()+3000, op );

Re-lancer et tester votre application