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.



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 :
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.


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

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

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());
    }
}

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

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

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.