---
# System prepended metadata

title: Android

---

Android
===

# Introduction

1- contenu d'un projet Android (Manifest, layout en XML, code java associé [cycle de vie d'une activié, gestion d'évènements])
2- les tâches asynchrones et leur utilité (handler, ...) 
3- les fragments (l'utilité, le contenu et les échanges avec les activités)
4- les intents (implicites et explicites) et leurs filtres + échange de données inter-activités
5- les étapes globales d'utilisation des capteurs (géolocalisation comme exemple)


1.Manifest file

It describes essential information about your app to the Android build tools, the Android operating system, and Google Play. 
Among many other things, the manifest file is required to declare the following:
•The app's package name, which usually matches your code's namespace. 
•The components of the app, which include all activities, services, broadcast receivers, and content providers. Each component must define basic properties such as the name of its Java class. It can also declare capabilities such as which device configurations it can handle, and intent filters that describe how the component can be started. 
•The permissions that the app needs in order to access protected parts of the system or other apps. It also declares any permissions that other apps must have if they want to access content from this app.
•The hardware and software features the app requires, which affects which devices can install the app from Google Play.

![](https://i.imgur.com/vnFwh4P.png)




![](https://i.imgur.com/ueQ3018.png)


MainActivity est la classe générée par défaut. Elle étend la classe AppCompatActivity.
Cette deuxième classe contient les fonctions `onCreate`, `onCreateOptionsMenu`, `onOptionsItemSelected` qui sont les fonctions par défaut et qui pourront être modifiées dans  MainActivity en utilisant `@Override`.

La ligne 16 est utilisée pour sauvegarder le contenu affiché à l'écran que l'on pourra restaurer plus tard.

La ligne 17 fait référence à un fichier `activity_main.xml` dans le dossier `res`. Ce fichier permet de définir le contenu affiché à l'écran.

Pour décrire ce fichier, il faut : 
1. Définir un arbre d'élement ou le noeud parent est le conteneur et les feuilles sont les widgets.
2. Définir tous les layouts dans chaque conteneur.
3. Définir les fonctions qui seront appelées lors des évenements sur l'écran.

Les attributs (taille, position...) sont définis dans les conteneurs sous forme d'héritage (Les attributs des conteneurs enfant héritent de ceux des conteneurs parents).

Ligne 21 : 
Dans le XML on voit : 
![](https://i.imgur.com/5hnPquM.png)
Le bouton flottant existe donc bien à l'écran.
La ligne 21 permet de créer un lien avec ce bouton flottant de façon à interragir avec celui-ci par la suite.

Tous les éléments à l'écran sont définit par un id dans le XML avec : `android:id=«@+id/myname»`

On pourra appeler cet élément n'importe où dans le XML en l'appelant sans le "+".

Ligne 22 : création du listener lié au bouton.


-----

# Layouts

TP2

Dans `res/values/strings.xml` on peut ajouter des valeurs que l'ont pourra utiliser ailleurs dans le code.

![](https://i.imgur.com/9riSNnJ.png)


Dans `res/layout/content_main.xml` on peut gérer l'interface de l'application.
* conteneurs
* layout
* bouttons
* ...

Dans `app/java/CurencyConverter` ajouter le code qui appelle les boutons mis en place.

---

UI Design

Dans l'arbre des éléments, la racine est souvent un **conteneur**.
Un objet en dessous du conteneur qui contient des éléments tels que des boutons sera un Layout.

L'arbre peut être statique, dynamique ou un mixte.


Un Layout Statique est définit dans un fichier XML, il va contenir d'autres éléments graphiques.

Exemple : 
```
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
<TextView
    android:id="@+id/text"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello, I am a TextView" />
<Button 
    android:id="@+id/button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello, I am a Button" />
</LinearLayout>
```
`xmlns:android` définit le namespace "android", il contient une liste de tag prédéfinit pour les éléments liés.

Dans tous les layouts, les éléments liés sont définit par par des attributs spécifiques : 
1. Des attributs qui définissent la position et les dimensions de l'éléments enfant
2. Les attributs intrinsèques tel que la couleur, le texte, l'id... sont dépendant du type d'élément utilisé.


`android:layout_width` et `android:layout_height` sont des tags qui définissent la taille du layout en fonction de sont conteneur.
2 valeurs possible : 
* `match_parent` : s'adapte à la taille du parent
* `wrap_content` : s'adapte à la taille du contenu

`android:orientation` : ce tag est spécifique au `LinearLayout` et définit comment les éléments enfants seront mis en place (vertical ou horizontal).

`android:id` (déjà vu plus haut)


Layout Manager : il gère la position et la dimension des éléments enfants selon les attributs : 

|Attribut|Description|Note|
|-|-|-|
|layout_width|Spécifie la largeur||
|layout_height|Spécifie la hauteur||
|layout_marginTop *ou* layout_marginBottom *ou* layout_marginLeft *ou* layout_marginRight|Spécifie la marge en haut, bas, gauche, droite||
|layout_gravity|Spécifie comment les enfants seront positionnés|Pour LinearLayout et TableLayout|
|layout_weight|Spécifie le ratio de l'écran|Pour LinearLayout et TableLayout|


`padding` est utilisé pour ajouter un espace entre le contenu et le conteneur.
`margin` est utilisé pour ajouter un espace entre les différents élements (parents et enfants).

Quand on ne connaît pas la taille de l'écran, il vaut mieux utiliser les dimensions relatives. Ainsi, l'élément enfant peut spécifier un poid qui symbolisera la priorité de l'élément. La valeur par défaut est zéro.


### Click Event

* 1ère solution

```java=
public class MyActivity extends Activity implements
    View.OnClickListener {
        protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Button button = (Button) findViewById(R.id.my_button);
        button.setOnClickListener(this);
        }
    public void onClick(View view) {
    // Display a notification popup during 1 second.
    Toast.makeText(this, "Button clicked !", 1000).show();
    }
}
```

* public : les objects instanciés dans cette classe sont visible de partout.
* private : sont visible seulement dans la classe
* protected : sont visible dans la classe et dans les classes descendantes.

* 2ème solution

```java=
public class MyActivity extends Activity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Button button = (Button) findViewById(R.id.my_button);
        button.setOnClickListener(new ButtonClickListener());
    }
}
```
```java=
public class ButtonClickListener implements View.OnClickListener {
    public void onClick(View view) {
    // Display a notification popup during 1 second.
    Toast.makeText(this, "Button clicked !", 1000).show();
    }
}
```

* 3ème solution

```java=
public classMyActivity extends Activity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Button button = (Button) findViewById(R.id.my_button);
        button.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
// Display a notification popup during 1 second.
            Toast.makeText(MyActivity.this, “Clicked!", 1000).show();
            }
        });
    }
}
```

### Autres évènements

```java=
EditText editText = (EditText) findViewById(R.id.my_text);
editText.setOnTouchListener(new View.OnTouchListener() {
    public boolean onTouch(View view, MotionEvent e) {
        Toast.makeText(MyActivity.this, "Touch!", 1000).show();
        return true; 
    // True means the listener has consumed the event.
    }
});

```

# Asynchronous tasks

Threads are “background” tasks that can be used in Android. However, if they tend to interact  with  the  UI,  then  this  could  cause  race  problems  that  have  to  be  solved appropriately  by  the  UI  thread.  For  this  purpose,  a  set  of  objects,  classes  (Handler, AsyncTask) have been added to Android which we’re going to cover in this lab.


