Refactor + commentaire +ratio

app/src/main/java/com/example/outilcuisson/AdaptateurPage.java

@@ -10,10 +10,25 @@ import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentActivity;
 import androidx.viewpager2.adapter.FragmentStateAdapter;
 
+/**
+ * Gestionnaire des différent fragments de l'application
+ *
+ * @author THIZY Alexandre
+ * @author VABRE Lucàs
+ * @author VILLENEUVE Noé
+ */
 public class AdaptateurPage extends FragmentStateAdapter {
 
+    /**
+     * Nombre de fragment de l'application
+     */
     private static final int NB_FRAGMENT = 2;
 
+    /**
+     * Crée une adaptateur de page
+     *
+     * @param activite le Main Activity de référence
+     */
     public AdaptateurPage(FragmentActivity activite) {
         super(activite);
     }

app/src/main/java/com/example/outilcuisson/AfficherFragment.java

@@ -21,27 +21,37 @@ import android.widget.ListView;
 
 import androidx.annotation.NonNull;
 import androidx.fragment.app.Fragment;
-import androidx.fragment.app.FragmentManager;
-import androidx.fragment.app.FragmentTransaction;
-
 
 import java.util.ArrayList;
 
+/**
+ * Fragment qui affiche la liste des cuissons de l'application
+ *
+ * @author THIZY Alexandre
+ * @author VABRE Lucàs
+ * @author VILLENEUVE Noé
+ */
 public class AfficherFragment extends Fragment {
 
     /**
-     * TODO
+     * Activité parente
      */
-    public ListView listView;
+    private MainActivity activity;
 
     /**
-     * TODO
+     * Liste visuelle des cuissons
+     */
+    private ListView listView;
+
+    /**
+     * Adapter qui fait le lien entre la liste visuelle et une ArrayList de
+     * String
      */
     public static ArrayAdapter<String> adapterCuissons;
 
-
+    /**
-    public AfficherFragment() {}
+     * @return une nouvelle instance de cette classe
-
+     */
     public static AfficherFragment newInstance() {
         return new AfficherFragment();
     }
@@ -55,14 +65,19 @@ public class AfficherFragment extends Fragment {
     public View onCreateView(LayoutInflater inflater,
                              ViewGroup container,
                              Bundle savedInstanceState) {
-        View view = inflater.inflate(R.layout.afficher_fragment, container,
+
-                                     false);
+        View view = inflater.inflate(R.layout.afficher_fragment, container,false);
+
+        /* Elements intéractifs */
         listView = view.findViewById(R.id.listeCuisson);
         adapterCuissons = new ArrayAdapter<>(getActivity(),
-            R.layout.ligne_liste, R.id.item_cuisson, new ArrayList<>());
+                R.layout.ligne_liste, R.id.item_cuisson, new ArrayList<>());
         listView.setAdapter(adapterCuissons);
         registerForContextMenu(listView);
 
+        /* Référence le main activity */
+        activity = (MainActivity) getActivity();
+
         return view;
     }
 
@@ -72,11 +87,15 @@ public class AfficherFragment extends Fragment {
         afficherCuisson();
     }
 
+    /**
+     * Met a jour la liste visuelle des cuissons par rapport au cuissons
+     * enregistré dans le MainActivity
+     */
     public void afficherCuisson() {
         adapterCuissons.clear();
 
         /* Ajoute l'objet cuisson  */
-        ArrayList<Cuisson> listeCuisson = ((MainActivity)getActivity()).getListeCuisson();
+        ArrayList<Cuisson> listeCuisson = activity.getListeCuisson();
 
         /* On affiche toutes les cuissons de la liste dans la view */
         for (Cuisson cuisson : listeCuisson) {
@@ -97,7 +116,7 @@ public class AfficherFragment extends Fragment {
                                     @NonNull View v,
                                     ContextMenu.ContextMenuInfo menuInfo) {
         new MenuInflater(getContext()).inflate(R.menu.menu_contextuel,
-                                                     menu);
+                menu);
         super.onCreateContextMenu(menu, v, menuInfo);
     }
 
@@ -108,7 +127,7 @@ public class AfficherFragment extends Fragment {
     @Override
     public boolean onContextItemSelected(@NonNull MenuItem item) {
         AdapterView.AdapterContextMenuInfo information
-            = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
+                = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
 
         int index = information.position;
 
@@ -117,7 +136,7 @@ public class AfficherFragment extends Fragment {
                 afficherThermos(index);
                 break;
             case R.id.modifierContext:
-                ((MainActivity) getActivity()).editerCuisson(index);
+                activity.editerCuisson(index);
                 break;
             case R.id.supprContext:
                 supprimerCuisson(index);
@@ -126,26 +145,36 @@ public class AfficherFragment extends Fragment {
         return super.onContextItemSelected(item);
     }
 
+    /**
+     * Crée une fenêtre qui montre les informations de la cuisson sélectionnée
+     * avec notamment la valeur du thermostat
+     *
+     * @param index indice de la cuisson sélectionné dans la liste des cuissons
+     */
     public void afficherThermos(int index) {
         /* Recupère l'objet cuisson */
-        Cuisson cuisson = ((MainActivity) getActivity()).getListeCuisson().get(index);
+        Cuisson cuisson = activity.getListeCuisson().get(index);
 
         String content = getString(R.string.alert_content_thermos,
-                                   cuisson.getPlat(),
+                cuisson.getPlat(),
-                                   cuisson.getDegree(),
+                cuisson.getDegree(),
-                                   cuisson.getThermostat());
+                cuisson.getThermostat());
-        new AlertDialog.Builder(getContext()).setTitle(R.string.alert_title_thermos)
+        new AlertDialog
-                                             .setMessage(content)
+                .Builder(getContext())
-                                             .setNeutralButton(R.string.alert_neutral_button,null)
+                .setTitle(R.string.alert_title_thermos)
-                                             .show();
+                .setMessage(content)
+                .setNeutralButton(R.string.alert_neutral_button, null)
+                .show();
     }
 
     /**
      * Supprime l'objet correspondant cuisson
-     * @param index
+     *
+     * @param index indice de la cuissons sélectionnée dans la liste des
+     *              cuissons
      */
     public void supprimerCuisson(int index) {
-        ((MainActivity) getActivity()).getListeCuisson().remove(index);
+        activity.getListeCuisson().remove(index);
         afficherCuisson();
     }
 }

app/src/main/java/com/example/outilcuisson/AjouterFragment.java

@@ -6,6 +6,7 @@
 
 package com.example.outilcuisson;
 
+import android.annotation.SuppressLint;
 import android.app.AlertDialog;
 import android.content.Context;
 import android.os.Bundle;
@@ -22,16 +23,49 @@ import androidx.fragment.app.Fragment;
 
 import java.util.ArrayList;
 
+/**
+ * Fragment qui comporte plusieurs champs à compléter et qui permet d'ajouter
+ * des cuissons à l'application
+ *
+ * @author THIZY Alexandre
+ * @author VABRE Lucàs
+ * @author VILLENEUVE Noé
+ */
 public class AjouterFragment extends Fragment {
 
+    /**
+     * Référence de l'activité parente
+     */
+    MainActivity activity;
+
+    /**
+     * Zone de texte correspondant au nom du plat
+     */
     EditText inputPlat;
+
+    /**
+     * Element graphique qui permet de sélectionner une durée
+     */
     TimePicker inputDuree;
+
+    /**
+     * Zone de texte correspondant a la température du plat
+     */
     EditText inputTemperature;
+
+    /**
+     * Boutton qui efface les champs et rétablie leurs valeurs par défaut
+     */
     Button btnEffacer;
+
+    /**
+     * Boutton qui essaye de créer/editer une cuisson si celle-ci est valide
+     */
     Button btnValider;
 
-    public AjouterFragment() {}
+    /**
-
+     * @return une nouvelle instance de la classe
+     */
     public static AjouterFragment newInstance() {
         return new AjouterFragment();
     }
@@ -51,7 +85,7 @@ public class AjouterFragment extends Fragment {
                              ViewGroup container,
                              Bundle savedInstanceState) {
 
-        View view = inflater.inflate(R.layout.ajouter_fragment, container,false);
+        View view = inflater.inflate(R.layout.ajouter_fragment, container, false);
 
         /* Liste des éléments intéractifs */
         inputPlat = view.findViewById(R.id.input_plat);
@@ -68,16 +102,20 @@ public class AjouterFragment extends Fragment {
         btnValider.setOnClickListener(this::actionBtnValider);
         btnEffacer.setOnClickListener(this::actionBtnEffacer);
 
+        /* Référence le main activity */
+        activity = (MainActivity) getActivity();
+
         return view;
     }
 
+    @SuppressLint("SetTextI18n")
     @Override
     public void onResume() {
         super.onResume();
 
         /* Si on est en mode edition, on préremplis le champs */
-        if ( ((MainActivity)getActivity()).modeEdition) {
+        if (activity.modeEdition) {
-            Cuisson cuisson = ((MainActivity)getActivity()).cuissonAEditer;
+            Cuisson cuisson = activity.cuissonAEditer;
 
             System.out.println(cuisson);
 
@@ -92,11 +130,17 @@ public class AjouterFragment extends Fragment {
     @Override
     public void onPause() {
         super.onPause();
-        ((MainActivity)getActivity()).modeEdition = false;
+        activity.modeEdition = false;
         champsDefaut();
     }
 
+    /**
+     * Action lors du clic sur le boutton Valider
+     *
+     * @param view Ecouteur d'évènement
+     */
     private void actionBtnValider(View view) {
+
         /* Récupère toutes les valeurs des champs */
         String txtPlat = inputPlat.getText().toString();
         String txtTemperature = inputTemperature.getText().toString();
@@ -106,78 +150,138 @@ public class AjouterFragment extends Fragment {
         /* Convertis la température en entier */
         int temperature = txtTemperature.isEmpty() ? -1 : Integer.parseInt(txtTemperature);
 
-        if (((MainActivity)getActivity()).modeEdition) {
+        /*
-            Cuisson cuisson = ((MainActivity)getActivity()).cuissonAEditer;
+         * Si le mode edition est activée, edite la cuisson, sinon crée une
-            try {
+         * nouvelle cuisson
-                cuisson.editCuisson(txtPlat, hDuree, mDuree, temperature);
+         */
+        if (activity.modeEdition)
+            editerCuisson(txtPlat, hDuree, mDuree, temperature);
+        else creerCuisson(txtPlat, hDuree, mDuree, temperature);
+    }
 
-                ((MainActivity)getActivity()).changeFragment(0);
+    /**
-            } catch (IllegalArgumentException e) {
+     * Edite une cuisson
-                /* Crée un boite de dialogue qui informe que les valeurs sont incorrectes */
+     *
-                new AlertDialog
+     * @param plat        Nouveau nom du plat
-                        .Builder(getContext())
+     * @param heure       La nouvelle durée en heure de la cuisson
-                        .setTitle(R.string.alert_title_error)
+     * @param minutes     La nouvelle durée en minutes de la cuisson
-                        .setMessage(R.string.alert_content_error)
+     * @param temperature La nouvelle température de la cuisson
-                        .setNeutralButton(R.string.alert_neutral_button,null)
+     */
-                        .show();
+    private void editerCuisson(String plat, int heure, int minutes, int temperature) {
-                e.printStackTrace();
+        Cuisson cuisson = activity.cuissonAEditer;
-            }
+        try {
-        } else {
+            cuisson.editCuisson(plat, heure, minutes, temperature);
-            /* On essaye de créer une nouvelle cuisson */
-            try {
-                Cuisson cuisson = new Cuisson(txtPlat, hDuree, mDuree, temperature);
 
-                /* On ajoute la cuisson a la liste des cuisson */
+            activity.changeFragment(0);
-                ((MainActivity) getActivity()).addCuisson(cuisson);
+        } catch (IllegalArgumentException e) {
+            /* Crée un boite de dialogue qui informe que les valeurs sont incorrectes */
+            new AlertDialog
+                    .Builder(getContext())
+                    .setTitle(R.string.alert_title_error)
+                    .setMessage(R.string.alert_content_error)
+                    .setNeutralButton(R.string.alert_neutral_button, null)
+                    .show();
+            e.printStackTrace();
+        }
+    }
 
+    /**
+     * Methode qui tente de créer une nouvelle Cuisson si elle est valide
+     *
+     * Si la cuisson est valide mais qu'elle existe deja, on demande si l'on
+     * veut l'éditer et change la valeur suivant le choix de l'utilisateur
+     *
+     * @param plat Le nouveau nom du plat
+     * @param heure La nouvelle durée en heure
+     * @param minutes La nouvelle durée en minutes
+     * @param temperature La nouvelle température du plat
+     */
+    private void creerCuisson(String plat, int heure, int minutes, int temperature) {
+        try {
+            Cuisson cuisson = new Cuisson(plat, heure, minutes, temperature);
+
+            /* On ajoute la cuisson a la liste des cuisson */
+            activity.addCuisson(cuisson);
+
+            /* Remet les champs vides */
+            champsDefaut();
+
+            /* Message que l'ajout est un succès */
+            String content = getString(R.string.toast_ajout_ok, cuisson.getPlat());
+            Toast.makeText(getContext(), content, Toast.LENGTH_SHORT).show();
+        } catch (IllegalArgumentException e) {
+
+            /*
+             * Crée un boite de dialogue qui informe que les valeurs sont
+             * incorrectes
+             */
+            new AlertDialog
+                    .Builder(getContext())
+                    .setTitle(R.string.alert_title_error)
+                    .setMessage(R.string.alert_content_error)
+                    .setNeutralButton(R.string.alert_neutral_button, null)
+                    .show();
+            e.printStackTrace();
+        } catch (CuissonDejaExistanteException e) {
+
+            /*
+             * La cuisson existe deja, on propose d'éditer le plat qui fait
+             * doublon
+             */
+            new AlertDialog
+                    .Builder(getContext())
+                    .setTitle(R.string.alert_title_doublon)
+                    .setMessage(R.string.alert_content_doublon)
+                    .setNegativeButton(R.string.alert_no_doublon, null)
+                    .setPositiveButton(R.string.alert_yes_doublon, (dialogInterface, i) -> {
+                        editerCuissonDoublon(plat, heure, minutes, temperature);
+                    })
+                    .show();
+        }
+    }
+
+    /**
+     * Recherche l'élément qui fait doublon dans la liste des cuissons de
+     * l'activity et change ses valeurs
+     *
+     * @param plat Nouveau nom du plat
+     * @param heure Nouvelle durée en heure
+     * @param minutes Nouvelle durée en minutes
+     * @param temperature Nouvelle température du plat
+     */
+    private void editerCuissonDoublon(String plat, int heure, int minutes,
+                                      int temperature) {
+
+        /* Récupère la liste des cuissons de l'activity */
+        ArrayList<Cuisson> listeCuisson = activity.getListeCuisson();
+
+        /* Recherche l'indice de l'élément qui fait doublon */
+        for (int j = 0; j < listeCuisson.size(); j++) {
+
+            /* Et modifie sa valeur avant d'arreter la fonction */
+            if (listeCuisson.get(j).getPlat().equals(plat)) {
+                listeCuisson.get(j).editCuisson(plat,
+                        heure, minutes, temperature);
                 champsDefaut();
-
+                return;
-                /* Message d'ajout */
-                String content = getString(R.string.toast_ajout_ok,
-                        cuisson.getPlat());
-                Toast.makeText(getContext(), content, Toast.LENGTH_SHORT).show();
-            } catch (IllegalArgumentException e) {
-
-                /* Crée un boite de dialogue qui informe que les valeurs sont incorrectes */
-                new AlertDialog
-                        .Builder(getContext())
-                        .setTitle(R.string.alert_title_error)
-                        .setMessage(R.string.alert_content_error)
-                        .setNeutralButton(R.string.alert_neutral_button,null)
-                        .show();
-                e.printStackTrace();
-            } catch (CuissonDejaExistanteException e) {
-                new AlertDialog
-                        .Builder(getContext())
-                        .setTitle(R.string.alert_title_doublon)
-                        .setMessage(R.string.alert_content_doublon)
-                        .setNegativeButton(R.string.alert_no_doublon,null)
-                        .setPositiveButton(R.string.alert_yes_doublon,
-                                           (dialogInterface, i) -> {
-                            ArrayList<Cuisson> listeCuisson = ((MainActivity)getActivity()).getListeCuisson();
-
-                            for (int j = 0; j < listeCuisson.size() ; j++) {
-                                if (listeCuisson.get(j).getPlat().equals(txtPlat)) {
-                                    listeCuisson.get(j).editCuisson(txtPlat, hDuree, mDuree, temperature);
-                                    champsDefaut();
-                                    break;
-                                }
-                            }
-                        })
-                        .show();
             }
         }
     }
 
     /**
-     * Efface le contenu des champs de textes et met le TimePicker à 0h40
+     * Action lors du clic sur le boutton Effacer
+     *
+     *
      * @param view non utilisé
      */
     private void actionBtnEffacer(View view) {
-        ((MainActivity)getActivity()).modeEdition = false;
+        activity.modeEdition = false;
         champsDefaut();
     }
 
+    /**
+     * Remet la valeurs des champs par défaut
+     */
     private void champsDefaut() {
         inputPlat.setText("");
         inputDuree.setHour(0);

app/src/main/java/com/example/outilcuisson/Cuisson.java

@@ -1,7 +1,22 @@
+/*
+ * Cuisson.java, 16/03/2022
+ * IUT Rodez 2021-2022, INFO 2
+ * pas de copyright, aucun droits
+ */
+
 package com.example.outilcuisson;
 
 import java.io.Serializable;
 
+/**
+ * Classe qui défini une cuisson
+ * Elements serealizable qui permettra d'être sauvegardé et chargé depuis un
+ * fichier
+ *
+ * @author THIZY Alexandre
+ * @author VABRE Lucàs
+ * @author VILLENEUVE Noé
+ */
 public class Cuisson implements Serializable {
 
     /**
@@ -38,12 +53,23 @@ public class Cuisson implements Serializable {
     private int minute;
     private int degree;
 
+    /**
+     * Crée une nouvelle cuisson
+     *
+     * @param plat La nom du plat
+     * @param heure La durée en heure
+     * @param minute La durée en minutes
+     * @param degree La température en degrée
+     * @throws IllegalArgumentException Si les valeurs passées en arguments
+     * ne sont pas corrects
+     */
     public Cuisson(String plat, int heure, int minute, int degree) {
         if (!platValide(plat)
                 || !horaireValide(heure, minute)
                 || !temperatureValide(degree)) {
             throw new IllegalArgumentException(CHAINE_DEFAUT);
         }
+
         this.plat = plat;
         this.heure = heure;
         this.minute = minute;
@@ -63,6 +89,15 @@ public class Cuisson implements Serializable {
                && !nomPlat.contains("|");
     }
 
+    /**
+     * Prédicat qui défini si un horaire est valide
+     * Les heures et les minutes doivent être valides et ne doivent pas être
+     * nulles
+     *
+     * @param heure La durée en heure a tester
+     * @param minute La durée en minutes a tester
+     * @return true si le prédicat est vérifié, false sinon
+     */
     public static boolean horaireValide(int heure, int minute) {
         return !(heure == 0 && minute == 0)
                 && heureCuissonValide(heure)
@@ -104,24 +139,42 @@ public class Cuisson implements Serializable {
     }
 
     /**
-     * @return
+     * @return Le nom du plat
      */
     public String getPlat() {
         return plat;
     }
 
+    /**
+     * @return La durée en heure
+     */
     public int getHeure() {
         return heure;
     }
 
+    /**
+     * @return La durée en minute
+     */
     public int getMinute() {
         return minute;
     }
 
+    /**
+     * @return La température en degré
+     */
     public int getDegree() {
         return degree;
     }
 
+    /**
+     * Edite la totalité des champs de la cuisson
+     *
+     * @param plat Le nouveau nom du plat
+     * @param heure La nouvelle durée en heure de la cuisson
+     * @param minute La nouvelle durée  en minutes de la cuisson
+     * @param degree Le nouvelle température de la cuisson
+     * @throws IllegalArgumentException Si les paramètres sont incorrects
+     */
     public void editCuisson(String plat, int heure, int minute, int degree) {
         if (!platValide(plat) || !horaireValide(heure, minute) || !temperatureValide(degree))
             throw new IllegalArgumentException();
@@ -134,74 +187,17 @@ public class Cuisson implements Serializable {
 
     @Override
     public String toString() {
-        StringBuilder aRenvoyer = new StringBuilder();
+        StringBuilder resultat = new StringBuilder();
 
-        // on insère le nom du plat
+        resultat.append(plat)
-        aRenvoyer.append(plat);
+                .append(chaineEspace(LG_MAX_PLAT - plat.length()))
-        aRenvoyer.append(chaineEspace(LG_MAX_PLAT - plat.length()));
+                .append(" | ");
-        aRenvoyer.append(" | ");
+        if (heure < 10) resultat.append(0);
+        resultat.append(heure).append(" h ");
+        if (minute < 10) resultat.append(0);
+        resultat.append(minute).append(" | ").append(degree);
 
-        // on insère la durée
+        return resultat.toString();
-        aRenvoyer.append(String.valueOf(heure));
-        aRenvoyer.append(" h ");
-        if (minute < 10) {
-            aRenvoyer.append("0");
-        }
-        aRenvoyer.append(String.valueOf(minute));
-        aRenvoyer.append(" | ");
-
-        // on insère la température
-        aRenvoyer.append(String.format("%3d", degree));
-        return aRenvoyer.toString();
-    }
-
-    /**
-     * Extrait d'une chaîne le nom du plat. On suppose que la chaîne est
-     * correctement
-     * formatée dans le format de la description d'une cuisson gérée par
-     * cette classe
-     * (les 20 premiers caractères de la chaîne sont extraits)
-     *
-     * @param source chaîne source de l'extraction
-     * @return une chaîne contenant le nom du plat ou CHAINE_DEFAUT si la chaîne
-     * argument est trop courte
-     */
-    public static String extrairePlat(String source) {
-        if (source.length() < LG_MAX_PLAT) {
-            return CHAINE_DEFAUT;
-        } else {
-            return source.substring(0, LG_MAX_PLAT);
-        }
-    }
-
-    /**
-     * Extrait d'une chaîne la température de cuisson. On suppose que la chaîne
-     * est correctement formatée dans le format de la description d'une cuisson
-     * gérée par cette classe  (la température est présente sur les 3 derniers
-     * caractères de la chaîne)
-     *
-     * @param source chaîne source de l'extraction
-     * @return un entier égal à la température extraite ou bien -1 si un
-     * problème inattendu a été rencontré avec le format de la chaîne
-     */
-    public static int extraireTemperature(String source) {
-        int temperature;                // température extraite
-        String chaineTemperature;       // température extraite en tant que chaîne
-
-
-        try {
-            chaineTemperature = source.substring(source.length() - 3,
-                                                 source.length());
-            temperature = Integer.parseInt(chaineTemperature);
-        } catch (NumberFormatException | IndexOutOfBoundsException erreur) {
-
-            /*
-             *  erreur lors de l'extraction des 3 derniers caractère
-             *  ou lors de la transformation en entier
-             */
-            temperature = -1;
-        }
-        return temperature;
     }
 
     /**

app/src/main/java/com/example/outilcuisson/CuissonDejaExistanteException.java

@@ -1,4 +1,18 @@
+/*
+ * CuissonDejaExistanteException.java, 16/03/2022
+ * IUT Rodez 2021-2022, INFO 2
+ * pas de copyright, aucun droits
+ */
+
 package com.example.outilcuisson;
 
+/**
+ * Exception levé lorsque l'utilisateur décide de créer une nouvelle cuisson
+ * qui à le même nom que l'une des cuissons déja crée dans l'application
+ *
+ * @author THIZY Alexandre
+ * @author VABRE Lucàs
+ * @author VILLENEUVE Noé
+ */
 public class CuissonDejaExistanteException extends Exception {
 }

app/src/main/java/com/example/outilcuisson/MainActivity.java

@@ -1,5 +1,12 @@
+/*
+ * MainActivity.java, 16/03/2022
+ * IUT Rodez 2021-2022, INFO 2
+ * pas de copyright, aucun droits
+ */
+
 package com.example.outilcuisson;
 
+import android.annotation.SuppressLint;
 import android.app.AlertDialog;
 import android.os.Bundle;
 import android.view.Menu;
@@ -8,7 +15,6 @@ import android.view.MenuItem;
 
 import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
-import androidx.fragment.app.FragmentManager;
 import androidx.viewpager2.widget.ViewPager2;
 
 import com.google.android.material.tabs.TabLayout;
@@ -16,26 +22,42 @@ import com.google.android.material.tabs.TabLayoutMediator;
 
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
-import java.io.FileReader;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
-
 
+/**
+ * @author THIZY Alexandre
+ * @author VABRE Lucàs
+ * @author VILLENEUVE Noé
+ */
 public class MainActivity extends AppCompatActivity {
+
     /**
      * Le nom du fichier de sauvegarde
      */
     private static final String NOM_FICHIER = "cuisson.txt";
 
+    /**
+     * La liste des cuissons de l'application
+     */
     private ArrayList<Cuisson> listeCuisson;
 
+    /**
+     * Le gestionnaire de Fragments de l'application
+     */
     private ViewPager2 gestionnairePagination;
 
+    /**
+     * Défini si l'utilisateur est entrain de éditer une cuisson
+     */
     public boolean modeEdition = false;
+
+    /**
+     * La cuisson que l'utilisateur est entrain de éditer
+     */
     public Cuisson cuissonAEditer;
 
     @Override
@@ -49,9 +71,7 @@ public class MainActivity extends AppCompatActivity {
 
         gestionnairePagination.setAdapter(new AdaptateurPage(this));
 
-        String[] titreOnglet = {
+        String[] titreOnglet = {getString(R.string.tab_afficher), getString(R.string.tab_ajouter)};
-            getString(R.string.tab_afficher), getString(R.string.tab_ajouter)
-        };
 
         new TabLayoutMediator(gestionnaireOnglet, gestionnairePagination,
                               (tab, position) -> tab.setText(
@@ -87,10 +107,20 @@ public class MainActivity extends AppCompatActivity {
         System.out.println(Arrays.asList(listeCuisson));
     }
 
+    /**
+     * @return La liste des cuissons de l'application
+     */
     public ArrayList<Cuisson> getListeCuisson() {
         return listeCuisson;
     }
 
+    /**
+     * Vérifie si la cuisson passée en paramètre est déja dans la liste des
+     * cuisson
+     *
+     * @param aTester La Cuisson a tester
+     * @return true si la cuisson est présente dans la liste, false sinon
+     */
     private boolean estDansCuisson(Cuisson aTester) {
         for (Cuisson cuisson : listeCuisson) {
             if (cuisson.getPlat().equals(aTester.getPlat())) return true;
@@ -98,17 +128,26 @@ public class MainActivity extends AppCompatActivity {
         return false;
     }
 
+    /**
+     * Lance l'edition d'une cuisson en redirigeant l'utilisateur vers le
+     * fragment d'édition, défini le que l'utilisateur est en mode édition et
+     * référence la cuisson a éditer dans la classe activity
+     *
+     * @param index L'indice de la cuisson à éditer dans la liste des cuissons
+     */
     public void editerCuisson(int index) {
         changeFragment(1);
         modeEdition = true;
         cuissonAEditer = listeCuisson.get(index);
     }
 
-
+    /**
+     * Charge le fichier de sauvegarde et attribue les cuissons sauvegardée
+     * dans la liste des cuissons
+     */
     private void chargerFichier() {
         try {
 
-
             FileInputStream fis = openFileInput(NOM_FICHIER);
             ObjectInputStream ois = new ObjectInputStream(fis);
 
@@ -122,6 +161,9 @@ public class MainActivity extends AppCompatActivity {
         }
     }
 
+    /**
+     * Suvegarde les liste des cuissons dans le fichier de sauvegarde
+     */
     private void sauvegarderFichier() {
         try {
             FileOutputStream fos = openFileOutput(NOM_FICHIER, MODE_PRIVATE);
@@ -137,7 +179,8 @@ public class MainActivity extends AppCompatActivity {
         }
     }
 
-    /* Crée le menu d'options en le désérialisant à partir du fichier
+    /*
+     * Crée le menu d'options en le désérialisant à partir du fichier
      * menu_options.xml
      */
     @Override
@@ -147,6 +190,7 @@ public class MainActivity extends AppCompatActivity {
     }
 
     /* Réalise l'action souhaité en fonction de l'item du menu selectionné */
+    @SuppressLint("NonConstantResourceId")
     @Override
     public boolean onOptionsItemSelected(@NonNull MenuItem item) {
         switch (item.getItemId()) {
@@ -154,12 +198,15 @@ public class MainActivity extends AppCompatActivity {
                 afficherAide();
                 break;
             case R.id.reinitOptions:
-                reinitData();
+                reinitialiserDonnees();
                 break;
         }
         return super.onOptionsItemSelected(item);
     }
 
+    /**
+     * Affiche le menu d'aide de l'application
+     */
     public void afficherAide() {
         new AlertDialog.Builder(this)
                 .setTitle(R.string.alert_title_aide)
@@ -168,7 +215,11 @@ public class MainActivity extends AppCompatActivity {
                 .show();
     }
 
-    public void reinitData() {
+    /**
+     * Supprime toutes les cuissons de l'application après confirmation de
+     * l'utilisateur
+     */
+    public void reinitialiserDonnees() {
         new AlertDialog.Builder(this)
                 .setTitle(R.string.alert_title_reinit)
                 .setMessage(R.string.alert_content_reinit)
@@ -180,6 +231,11 @@ public class MainActivity extends AppCompatActivity {
                 .show();
     }
 
+    /**
+     * Change le fragment courrant
+     *
+     * @param pos indice du fragment dans le ViewPager2
+     */
     public void changeFragment(int pos) {
         gestionnairePagination.setCurrentItem(pos);
     }