Structure d’une application

Composantes d’une application

Une application a pour composants généraux : un manifeste, un dossier java avec les fichiers kotlin des activités et un dossier ressources avec notamment les images et les layouts correspondants des activités (en XML).

Une page de l’application est une activité. Chaque activité possède un fichier de code (Kotlin, contrôleur graphique) et un fichier de vue ou layout (XML).

Manifest

Le manifeste est la référence de l’application, obligatoire. Il donne le nom de l’application, les icônes, la liste des pages… Toutes les pages (= activités) doivent être inscrites dans le manifeste (ce qui est fait automatiquement). La balise intent-filter est le point d’entrée de l’application.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/Theme.MumblingInKotlin"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Activités et layouts

Une activité est un écran de l’application sous forme d’une classe Kotlin, stockées dans le dossier java dans des packages nommés par convention selon l’auteur et le nom du projet.

package com.lsarribouette.mumblinginkotlin

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Une application est composée d’une ou plusieurs activités. Grâce au contrôleur graphique, on peut réagir aux actions de l’utilisateur.

Dans Android Studio, un fichier layout s’affiche soit en mode Design (qui permet de choisir le layout, d’ajouter et modifier les vues et leurs attributs) soit en mode Code (qui traduit le résultat en code XML, bien sûr modifiable).

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Ressources

La gestion des ressources est plus contraignante qu’en web : le nom des dossiers est fondamental.

Dans res, les ressources sont d’abord organisées par catégorie :

Chacune de ces catégories peut être complétée avec un ou plusieurs qualificateurs : densité d’écran (mdpi à xxxhdpi), landscape, langue (en, fr…), nightmode. Il est possible de préciser la version d’Android utilisée.

Les informations sont séparées par un tiret -. Un dossier est donc nommé avec plus ou moins d’informations : categorie, categorie-qualif, categorie-version, categorie-qualif1-qualif2-version...

Pour ajouter une ressource :

BP : on préfère utiliser des formats vectoriels (XML sous forme d’une somme de couches SVG) qui sont plus légers, plus adaptables.

Pour accéder à une ressource,

• en Kotlin, on utilise R.type.identifiant-ressource (par exemple : R.string.hello, R.layout.activity_main)

• en XML, on utilise @type/identifiant-ressource (par exemple, @string/hello)

Exemple : afficher une icône

<ImageView
        android:id="@+id/imageView"
        android:layout_width="75dp"
        android:layout_height="81dp"
        android:layout_marginBottom="48dp"
        android:contentDescription="Une jolie fleur pour mon Hello World"
        app:layout_constraintBottom_toTopOf="@+id/textView"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="1.0"
        app:srcCompat="@drawable/outline_local_florist_24" />

Interfaces graphiques

Tout ce qui est graphique étend View.

Il y a deux types de vues : les vues classiques View (textes, images, formulaires, boutons…) et les groupes de vues ViewGroup ou layout (qui organise les éléments entre eux).

BP : On met les vues dans des layouts pour faciliter l’organisation dans la page (ce qui signifie que toute zone de texte ou bouton est contenue dans un layout et rien ne se balade tout seul).

View

Quelques exemples de vues disponibles.

Les vues les plus communes :

Les boutons :

Les inputs (saisies par l’utilisateur) :

Les widgets :

ViewGroup (ou Layout)

Les layouts disponibles :

Un LinearLayout organise les vues horizontalement ou verticalement.

Un FrameLayout ne contient qu’une seule vue qui recouvre tout l’espace.

Un ConstraintLayout permet de positionner les vues selon des contraintes et selon d’autres vues (par exemple, deux boutons que l’on chaine et qui se placent dynamiquement au centre — même leur taille est dynamique).

⚠️

On est obligé de contraindre toutes les vues du ConstraintLayout.

BP : on n’utilise pas le GridLayout parce que c’est statique, on utilise plutôt une liste avec un affichage sous forme de grille. BP : on crée des layouts spécifiques pour les différentes tailles d’écran.

Dimensions

Deux unités de mesure :

• sp = scale-independent pixels —> pour les polices d’écriture

• dp = density-independent pixels —> pour le reste

Android gère déjà la police du téléphone (accessibilité) donc il faut utiliser le sp.

Internationalisation

Pour un TextView, on n’écrit pas directement la valeur de la String à afficher mais la référence à une variable (constante) : @string/id_string_a_afficher.

Les Strings sont stockées dans un fichier strings.xml dans res/values.

<resources>
    <string name="app_name" translatable="false">MumblingInKotlin</string>
    <string name="icon_flower_name">Une jolie fleur pour mon Hello World</string>
</resources>

Pour traduire l’application dans plusieurs langues, on crée un fichier par langue avec le qualificateur correspondant (-en, -fr, -de…).

• clique-droit sur values > New > Values Resource File

  > File name : toujours strings (il mettra le .xml), choix du qualificateur : Locale en

  > Finish

• on peut aussi créer le fichier depuis l’éditeur Translations Editor

On ajoute ensuite les Strings traduites, à la main dans le fichier ou depuis l’éditeur.

<resources>
    <string name="app_name">MumblingInKotlin</string>
    <string name="icon_flower_name">A nice flower for my Hello World</string>
</resources>