Ressources Android et actions

Présentation des différents composants d'une application Android

• Une application Android est un ensemble de composants liés grâce à un fichier de configuration.
• Ce fichier de configuration est un fichier XML nommé AndroidManifest.xml.
• Il décrit notamment le point d'entrée de l'application et les composants (activités, services, etc.).
• Il définit aussi les permissions nécessaires pour l'exécution du programme.

Fichier de configuration Android (manifest)

• L'application Android est un assemblage de composants liés grâce à un fichier de configuration.
• Ce fichier décrit le point d'entrée de l'application (quel code doit être exécuté au démarrage).
• Il précise également les composants qui constituent l'application Android (activités, services, etc.) et les permissions nécessaires à son exécution.
• Le format de ce fichier est XML.

Exemple

• L'exemple de fichier AndroidManifest.xml illustre le format XML et les éléments clés.
• Le fichier spécifie le package de l'application, le numéro de version et l'icône de l'application.
• Il définit les activités de l'application et leurs propriétés.
• Les balises <activity>, <service>, <receiver> et <provider> représentent les composants de l'application.

Composants d'une application Android

• Les composants d'une application Android peuvent être classés en éléments applicatifs et éléments d'interaction.
• Les éléments applicatifs incluent : Activité, Service, Fournisseur de contenu et Gadget (widget).
• Les éléments d'interaction incluent : Objet Intent, Récepteur d'Intents et Notification.

Activités de l'application

• Une activité correspond à une partie de l'application correspondant à un écran.
• Elle représente le bloc de base d'une application Android.
• Une activité est composée d'une hiérarchie de vues contenant chacune des vues.
• Elle gère la présentation de l'application et réagit aux actions de l'utilisateur.
• Une application avec plusieurs écrans possédera autant d'activités.

Utilisation

• Une activité est composée de deux volets: la logique métier et la gestion de son cycle de vie (implémentée en Java dans une classe héritant de Activity).
• Son interface utilisateur peut être définie de manière programmative dans le code de l'activité ou déclarative dans un fichier XML.

Logique métier d'une activité : Squelette minimal

• Le code fournit un exemple minimaliste de la logique métier d'une activité, illustrant l'importation des classes Activity et Bundle.
• La méthode onCreate() est appelée lors de la création de l'activité et est responsable de l'initialisation.

La balise

• La balise <activity> déclare une activité dans le fichier manifest.
• Elle contient des paramètres tels que name (nom de la classe de l'activité), label (nom texte de l'activité qui apparait sur le terminal), icon (icône de l'activité).

Cycle de vie d'une activité

• Les activités Android passent par différentes phases ou états ("active", "paused", "stopped", "destroyed").
• La méthode onCreate() est essentielle au lancement initiale de l'activité.
• Les méthodes onResume(), onPause(), onStart() et onStop() traitent les changements d'état de l'activité.
• La méthode onDestroy() est lancée lors de la destruction de l'activité (par exemple, quand l'application est fermée).

Cycle de vie d'une activité Main

• Cette section fournit un exemple complet du cycle de vie d'une activité Main qui étend Activity.
• Les méthodes onCreate(), onDestroy(), onPause(), onResume(), onStart(), onStop() et onRestart() essentielles pour gérer les différentes phases de l'activité sont présentées.

Les interfaces d'applications : Les Vues

• Les vues sont les briques de construction de l'interface graphique d'une activité Android.
• Elles peuvent être prédéfinies par la plateforme (ex : Textes, Boutons) ou personnalisées par l'utilisateur.
• Chaque écran contient un arbre d'éléments de type View.

Les interfaces d'applications Android

• Les composants graphiques (boutons, images, cases à cocher) héritent de la classe View.
• Les vues peuvent être regroupées dans une structure arborescente à l'aide de ViewGroup.
• L'utilisation et le positionnement des vues sont gérés via des gabarits de vues.

Positionnement des vues avec les gabarits

• Les gabarits (layouts) sont des conteneurs pour positionner les objets (vues, autres gabarits).
• Il existe différents types de gabarits: LinearLayout, RelativeLayout, TableLayout.
• Ils permettent d'organiser les éléments sur l'écran (horizontalement, verticalement, dans un tableau, etc.).

Les propriétés communes à tous les types de gabarit

• layout_weight et layout_height définissent le comportement de remplissage en largeur et en hauteur.
• Les unités de mesures (taille précise en pixels, relative en DIP ou SP) impliquent des ajustements automatiques pour des tailles d'écran différentes.

Valeurs prédéfinies

• fill_parent : la vue prend toute la place disponible sur l'axe de disposition.
• wrap_content : la vue prend uniquement l'espace nécessaire à son contenu.

Création d'une interface utilisateur

• L'interface utilisateur peut être créée directement dans le code (instanciation de vues) ou de manière déclarative (dans un fichier XML).
• La méthode setContentView instancie et affiche un Layout existant.

Définition de l’interface en XML

• Les fichiers XML de définition d'interface sont stockés dans le dossier res/layout.
• Chaque fichier XML est associé à un ID unique utilisable dans le code.

Association entre activité et interface

• L'interface est affichée via une activité.
• La méthode setContentView(id) charge et affiche la ressource d'interface associé à l'ID.
• Il faut redéfinir la méthode OnCreate de l’activité pour spécifier la définition de l’interface à afficher à l'aide de la méthode setContentView.

Spécification d'une vue pour l'activité

• Le code d'exemple montre comment spécifier une vue pour une activité en utilisant setContentView.
• Il illustre comment importer android.app.Activity et android.os.Bundle, créer une nouvelle activité étendue de la classe Activity, et définir la vue principale à l'aide de setContentView.

Création une interface dans le code source (sans définition XML)

• Le code d'exemple présente la création d’une interface dans le code source, sans utiliser de fichier XML déclaratif.
• Il instancie un objet TextView, définit son contenu et affiche ce TextView en utilisant setContentView.

Utilisation des gabarits

• Pour intégrer une ou plusieurs vue à une activité, on utilise des gabarits de vues (layouts).
• La méthode setContentView() permet de spécifier le layout à afficher.
• On peut utiliser des layouts prédéfinis (ex: LinearLayout avec setOrientation(VERTICAL | HORIZONTAL)) ou créer ses propres layouts en XML.

Gestion des événements

• Les actions utilisateur sont traitées comme des événements capturés par les éléments d'une interface utilisateur.
• Les événements sont gérés à travers des écouteurs (listeners).
• Un clic (onClic()) sur un objet graphique déclenche une méthode d'écouteur associée.

Insertion d’un bouton dans l’interface

• L’exemple montre comment insérer un bouton dans une interface XML.
• On utilise la balise <Button> pour définir le bouton.

Création d'un écouteur sur un bouton

• Le code illustré crée un écouteur personnalisé (OnClickListener) pour un bouton.
• La méthode onClick du listener est exécutée en réaction au clic sur le bouton, affichant un message via Toast.

Les ressources

• Les ressources sont des fichiers externes qui ne contiennent pas d'instructions.
• Elles incluent des images (JPEG, PNG), fichiers XML, etc.
• Android fournit la classe R pour référencer les ressources.

Type de ressources

• Différents types de ressources sont gérés (valeurs simples, drawables, layouts, animations, ressources XML, ressources brutes).
• Chaque type a un répertoire spécifique dans votre projet Android (res_values, res_drawable, res_layout, etc.).

Création de ressources

• Les ressources (entiers, booléens, chaînes de caractères...) peuvent être définies déclarativement dans un fichier XML.
• L'ID unique de chaque ressource est utilisée dans le code pour l'utiliser comme paramètre de la classe R.

Utilisation des ressources

• On utilise les ressources via leur identifiant présent dans la classe R. String hw = res.getString(R.string.hello);
• Il faut spécifier un namespace (android.R.id.) avant l'utilisation d'une ressource R dans un findViewById().

Utilisation des ressources dans les fichier XML

• Les ressources déclarées dans les fichiers XML sont référencées avec le préfixe @. @string/table_contenu_cellule_gauche.

Autres composants

• Un service est un composant qui fonctionne en arrière-plan (invisibles pour l'utilisateur).
• Un gadget est un composant graphique qui s'affiche sur le bureau Android (par ex. le calendrier).
• Un fournisseur de contenu permet de gérer et de partager des informations entre différentes applications et au sein d'une même application.

Communication entre composants

• L'interaction entre composants se fait via les objets Intent.
• Les Intent permettent de lancer des actions (ou des composants) dans d'autres applications ou au sein de la même application, ou encore d'échanger des données.

Objets Intent

• Les Intents sont les objets pour exprimer ce qu'une application souhaite faire (opération).
• Les Intents peuvent être utilisés pour :
  • lancer une autre activité
  • faire communiquer une activité avec une autre
  • envoyer des données entre ces activités
• Les Intents possèdent des éléments pour les actions à faire, leurs données, etc.

Principe de fonctionnement

• Les Intents permettent de :
  • démarrer une activité au sein de l'application (navigation).
  • déclencher l'exécution d'actions dans d'autres applications.
  • transmettre des données entre applications ou activités.

Naviguer entre écrans

• Démarrer une activité sans attendre de retour via startActivity().
• Démarrer une activité et obtenir un retour via startActivityForResult().
• Ceci inclut l'utilisation des méthodes ForResult() et les arguments requestCode et resultcode et la réception de valeurs retournées.

Utilisation d’Intent implicite

• Pour solliciter une action d'une autre application, on utilise un Intent implicite.
• L'Intent doit définir les actions, les donnés (URI) et le type de contenu (MIME Type) pour permettre au système de trouver l'application/composant approprié à exécuter.

Spécifier les permissions liées aux actions

• Certaines actions, comme les appels téléphoniques ou l'accès aux données réseau, nécessitent des permissions spécifiques à déclarer dans le fichier AndroidManifest.xml via les balises <uses-permission>.

Filtrer les actions

• Les applications peuvent définir la liste des actions qu'elles permettent d'exécuter via les balises <intent-filter>.
• L'attribut android:name de la balise <action> et <category> spécifie les actions et catégories prises en charge.

Réagir à la réception d'un Intent

• Pour réagir à la réception d'un Intent, l'activité doit implémenter la méthode onActivityResult().
• Cela permet d'accéder et de traiter les données envoyées par la requête d'Intent.

Permissions

• Pour accéder aux données personnelles (contacts , calendrier, etc.), les permissions appropriées sont nécessaires.
• Ces permissions doivent être déclarées dans le fichier AndroidManifest.xml (balise <uses-permission>).
• Certaines actions comme passer un appel téléphonique, acceder aux contacts ou au compte Google pourraient nécessiter des permissions explicites.

Configuration de l'affichage

• L'affichage d'une liste d'éléments dans une activité Android se fait habituellement avec le composant RecyclerView.
• RecyclerView gère l'affichage des éléments, permettant un défilement optimisé.
• On configure l'affichage du RecyclerView via des LayoutManagers (e.g. LinearLayoutManager, StaggeredGridLayoutManager).
• Ces classes gèrent l'organisation des éléments sur l'écran selon leurs propriétés ou le type d'affichage souhaité (liste, grille, etc.).

Optimisation du défilement

• RecyclerView.setHasFixedSize(true) est important pour une bonne optimisation d'affichage, surtout pour les grands ensembles d'éléments.

LayoutManager

• Il définit comment les éléments de RecyclerView s'organisent (grille, liste, etc).
• Il faut spécifier un objet LayoutManager approprié au RecyclerView.

LayoutManager dans le layout.xml

• On peut définir le type de LayoutManager directement dans le fichier XML du layout du RecyclerView.

Layout Manager, suite

• LinearLayoutManager : dispose les éléments en liste (vertical ou horizontal).
• GridLayoutManager : dispose les éléments en grille.
• StaggeredGridLayoutManager : dispose les éléments en grille, en autorisant des hauteurs d'éléments variables.

Separateur entre items

• Des séparateurs peuvent être ajoutés entre les éléments d'une liste RecyclerView.
• DividerItemDecoration définit des séparateurs dans une liste.

Actions sur la liste

• La gestion des clics sur les éléments d'une liste RecyclerView (par ex. action de sélection, etc.) implique l'utilisation d'interfaces OnItemClickListner.
• Les méthodes de notification (notifyItemInserted, notifyItemChanged, etc.) informuent l'adaptateur des changements apportés à la liste sous-jacente.

Défilement vers un élément

• scrollToPosition(int pos) permet de faire défiler rapidement le RecyclerView à la position demandée.

Clic sur un élément

• L'utilisateur interagit avec les éléments d'une liste, avec des clics simples ou longs.
• Le lien entre l’activité MainActivity et l’élément cliqué passe obligatoirement par ViewHolder et OnItemClickListener.
• Un click utilisateur est reçu par le ViewHolder correspondant et déclenche un listener sur un objet qui doit être mis à jour dans MainActivity.

Notre écouteur de clic

• Une interface OnItemClickListener est définie pour gérer les clics sur les éléments.

Notre écouteur de clics, suite

• Les ViewHolders doivent mémoriser et mettre à jour l'écouteur OnItemClickListener.
• L'adaptateur (PlaneteAdapter) doit transmettre l'interface OnItemClickListener aux ViewHolders pendant la création.

Notre écouteur de clics, suite et fin

• L'activité MainActivity implémente l'interface OnItemClickListener pour garantir la propagation des actions aux objets concernés.

Schéma récapitulatif

• Le schéma met en évidence les flux de données entre l'activité, l'adaptateur et les ViewHolders.
• L'adaptateur gère la liste de données et la passe aux ViewHolders.
• Un clic sur un ViewHolder déclenche l'écouteur dans l'adaptateur.

Bases de données SQLite

• SQLite : une base de données embarquée dans Android, idéale pour les applications Android.

• SQLiteOpenHelper : une classe pour gérer la création/mise à jour des bases de données SQLite sur chaque appareil Android.

• Les méthodes onCreate, onUpgrade permettent de créer et de mettre à jour les tables.

• SQLiteDatabase : permet l'accès aux opérations SQL sur les bases de données SQLite.

• La classe DAO (Data Access Objects) contient les méthodes pour exécuter les requêtes SQL.

• Cursor : utilisé pour parcourir les données retournées par les requêtes SQL.

Les curseurs

• Les curseurs sont des objets qui contiennent les résultats d'une requête SQL.
• moveToFirst(), moveToNext(), etc. permettent de naviguer dans le jeu de résultats.

Testez vos connaissances sur les types de ressources dans une application Android et les actions associées. Ce quiz couvre les répertoires de ressources, les classes essentielles, et les actions comme ACTION_SEND et ACTION_VIEW. Découvrez si vous êtes à jour sur les meilleures pratiques de gestion des ressources en Android.