From feb779db25aecb96d95ec06d04631c9054b3709a Mon Sep 17 00:00:00 2001 From: LucasV-IUT Date: Wed, 16 Mar 2022 23:21:00 +0100 Subject: [PATCH] Refactor + commentaire +ratio --- .../example/outilcuisson/AdaptateurPage.java | 15 ++ .../outilcuisson/AfficherFragment.java | 81 ++++-- .../example/outilcuisson/AjouterFragment.java | 230 +++++++++++++----- .../com/example/outilcuisson/Cuisson.java | 130 +++++----- .../CuissonDejaExistanteException.java | 14 ++ .../example/outilcuisson/MainActivity.java | 80 +++++- 6 files changed, 382 insertions(+), 168 deletions(-) diff --git a/app/src/main/java/com/example/outilcuisson/AdaptateurPage.java b/app/src/main/java/com/example/outilcuisson/AdaptateurPage.java index fe3a0a2..4f0a0a4 100644 --- a/app/src/main/java/com/example/outilcuisson/AdaptateurPage.java +++ b/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); } diff --git a/app/src/main/java/com/example/outilcuisson/AfficherFragment.java b/app/src/main/java/com/example/outilcuisson/AfficherFragment.java index 1bb4cbd..6bbb49f 100644 --- a/app/src/main/java/com/example/outilcuisson/AfficherFragment.java +++ b/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 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 listeCuisson = ((MainActivity)getActivity()).getListeCuisson(); + ArrayList 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.getDegree(), - cuisson.getThermostat()); - new AlertDialog.Builder(getContext()).setTitle(R.string.alert_title_thermos) - .setMessage(content) - .setNeutralButton(R.string.alert_neutral_button,null) - .show(); + cuisson.getPlat(), + cuisson.getDegree(), + cuisson.getThermostat()); + new AlertDialog + .Builder(getContext()) + .setTitle(R.string.alert_title_thermos) + .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(); } } diff --git a/app/src/main/java/com/example/outilcuisson/AjouterFragment.java b/app/src/main/java/com/example/outilcuisson/AjouterFragment.java index d968a41..c9ce4cb 100644 --- a/app/src/main/java/com/example/outilcuisson/AjouterFragment.java +++ b/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) { - Cuisson cuisson = ((MainActivity)getActivity()).cuissonAEditer; + if (activity.modeEdition) { + 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; - try { - cuisson.editCuisson(txtPlat, hDuree, mDuree, temperature); + /* + * Si le mode edition est activée, edite la cuisson, sinon crée une + * nouvelle cuisson + */ + if (activity.modeEdition) + editerCuisson(txtPlat, hDuree, mDuree, temperature); + else creerCuisson(txtPlat, hDuree, mDuree, temperature); + } - ((MainActivity)getActivity()).changeFragment(0); - } 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(); - } - } else { - /* On essaye de créer une nouvelle cuisson */ - try { - Cuisson cuisson = new Cuisson(txtPlat, hDuree, mDuree, temperature); + /** + * Edite une cuisson + * + * @param plat Nouveau nom du plat + * @param heure La nouvelle durée en heure de la cuisson + * @param minutes La nouvelle durée en minutes de la cuisson + * @param temperature La nouvelle température de la cuisson + */ + private void editerCuisson(String plat, int heure, int minutes, int temperature) { + Cuisson cuisson = activity.cuissonAEditer; + try { + cuisson.editCuisson(plat, heure, minutes, temperature); - /* On ajoute la cuisson a la liste des cuisson */ - ((MainActivity) getActivity()).addCuisson(cuisson); + activity.changeFragment(0); + } 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 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(); - - /* 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 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(); + return; } } } /** - * 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); diff --git a/app/src/main/java/com/example/outilcuisson/Cuisson.java b/app/src/main/java/com/example/outilcuisson/Cuisson.java index f7b8987..7433962 100644 --- a/app/src/main/java/com/example/outilcuisson/Cuisson.java +++ b/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 - aRenvoyer.append(plat); - aRenvoyer.append(chaineEspace(LG_MAX_PLAT - plat.length())); - aRenvoyer.append(" | "); + resultat.append(plat) + .append(chaineEspace(LG_MAX_PLAT - plat.length())) + .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 - 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; + return resultat.toString(); } /** diff --git a/app/src/main/java/com/example/outilcuisson/CuissonDejaExistanteException.java b/app/src/main/java/com/example/outilcuisson/CuissonDejaExistanteException.java index 3d3078d..a7ff101 100644 --- a/app/src/main/java/com/example/outilcuisson/CuissonDejaExistanteException.java +++ b/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 { } diff --git a/app/src/main/java/com/example/outilcuisson/MainActivity.java b/app/src/main/java/com/example/outilcuisson/MainActivity.java index 4875edd..b122fa7 100644 --- a/app/src/main/java/com/example/outilcuisson/MainActivity.java +++ b/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 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 = { - getString(R.string.tab_afficher), getString(R.string.tab_ajouter) - }; + String[] titreOnglet = {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 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); }