IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Android Discussion :

Structure de la MainActivity de l'application


Sujet :

Android

  1. #1
    Membre régulier Avatar de vertebre
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2015
    Messages
    184
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2015
    Messages : 184
    Points : 111
    Points
    111
    Par défaut Structure de la MainActivity de l'application
    Bonjour,

    Je me demande comment structurer la première activité de mon application, celle qui va instancier mes objets, faire les traitements nécessaires au démarrage de l'application.
    J'ai tenter de coder cette activité mais je me retrouve avec des tonnes de if else imbriqués, et je rencontre plusieurs problèmes au niveau du fils d’exécution du code (car tout s'exécute d'un coup).

    En cherchant, j'ai trouvé les threads et les handlers qui me permettrait (si j'ai bien compris) de sectionner mes traitements tout en gardant un contrôle sur le fils et l'ordre d’exécution.
    Mais bon n'en suis pas sur

    Donc pour structurer ou organiser cette MainActivity, quelles techniques (threads etc ...) utilisent t on pour instancier les objets (bases) de mon application Android ?

  2. #2
    Membre régulier
    Homme Profil pro
    Développeur .NET
    Inscrit en
    octobre 2015
    Messages
    55
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : octobre 2015
    Messages : 55
    Points : 82
    Points
    82
    Par défaut
    Bonjour tout depends de ce que tu appelles objet de base de ton application. Donne un exemple precis de ton MainActivity et de ce que tu veux faire; on pourra ainsi te donner une aide utile.

    Sinon regarde le lifeCycle callbacks ; c'est un bon debut.

  3. #3
    Membre régulier Avatar de vertebre
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2015
    Messages
    184
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2015
    Messages : 184
    Points : 111
    Points
    111
    Par défaut
    Bonjour,

    -| Je viens de regarder ton lien concernant le lifeCycle callbacks.
    Je connaissais les étapes du cycle de vie d'une activité, mais ce qui m'a interpellé c'est le mot 'callback' pourquoi l'utiliser car onCreate(), onResume(), etc ... ne renvoie rien ? je fais peut être une fixation sur ce mot pour rien mais bon on en parle alors je m'exprime


    -| Concernant ma MainActivity (qui sert à initialiser l'application), je veux faire les traitements 1,2,3,4 en gérant le fait que l'utilisateur démarre l'application pour la 1ere fois ou qu'il l'a déjà fait.

    1 /* Allumer le GPS et obtenir la localisation */
    Je m'assure que le GPS soit allumée pour ces traitements comme pour la suite. s'il n'est pas activé je demande à l'utilisateur de l'ouvrir avec un alert Dialog.
    Les données de localisation je les stocke dans des variables temporaires pour les setter sur les objets que je vais instancier juste après

    2 /* Initialise les données et objet de l'application */
    Créer des objets par default (un objet Gson par exemple, puis les objets permettant de représenter les données d'un utilisateur, disons un objet Profil et un objet Login, et d'autres.
    Tous ces objets seront stockés et serviront pour les traitements suivants et pour les activity suivantes.

    3 /* Créer ou ouvrir les BDD SQLite et peupler directement les nouveaux utilisateurs */
    Créer les BDD et enregistrer les objets dedans.
    Mettre à jour les données de localisation.
    Récupérer les données que j'ai besoin et les enregistrer dans les préférences partagées.

    4 /* Construire la logique de l'application manquante pour que l'utilisateur soit redirigé vers l'activity suivante en fonction des valeurs des objets existants*/
    Logiques de l'application basée sur des étapes de vérifications et de conditions qui ouvrira des intents particuliers en fonction des valeurs des données utilisateurs(attributs des objets).

    Je voudrais que toutes ces actions soient réalisées pendant que l'utilisateur verra une progressbar avancer.


    -|Au début je faisais tous ces traitements dans ma MainActivity, mais cela me posait des problèmes car tous le code s'exécutait d'un coup, comme je voulais avancé dans mon projet, j'ai :

    -Créer un Intentservice pour effectuer mes traitements
    -Mis un handler pour mettre à jour la progressbar

    J'ai hésité longtemps entre :
    -Choisir un Service ou intentService ==> J'ai donc choisi un intentService.
    -Savoir si dans mon service je faisais mes traitements séparément(plusieurs procédures onHandleIntent) ou dans un seul ==> J'ai donc choisi de faire les traitements dans une seule procédure onHandleIntent().

    Il y a aussi le problème de lancer l'alert dialog depuis un intentService qui n'est pas possible je crois. peux tu me le confirmer stp ?

    Je voudrais bien t'en dire un peu plus sur ce que j'ai fait mais j'aimerai que tu me confirmes déjà si les composants choisis peuvent me permettre de mettre en place les traitements de ma MainActivity.


    bonne journée,

  4. #4
    Membre régulier Avatar de vertebre
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2015
    Messages
    184
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2015
    Messages : 184
    Points : 111
    Points
    111
    Par défaut
    du coup je relance ma question ...

  5. #5
    Modérateur
    Avatar de grunk
    Homme Profil pro
    Lead dév - Architecte
    Inscrit en
    août 2003
    Messages
    6 435
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Lead dév - Architecte
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 435
    Points : 18 772
    Points
    18 772
    Par défaut
    L'intent service ou le service n'est à mon avis pas la solution dans ton cas.
    L'intent service est utilisé pour réaliser quelque chose en tache de fond , dont on à pas vraiment besoin de s'occuper.

    Tu sembles plutôt vouloir faire attendre l'utilisateur avec un progressbar le temps du chargement :

    Du coup une ou plusieurs asyncTask me semble être plus judicieux.

    - Dans ton onCreate/OnResume (en fonction du besoin) tu lance ton asyncTask
    - Tu affiches une progressBar via par exemple le méthode onPreExecute() de ton asyncTask
    - Tu fais ton chargement dans doInBackground() .
    - Tu peux éventuellement mettre à jour l'état du chargement via onProgressUpdate() .
    - Tu masques la progressBar dans onPostExecute() .

    Si tu as besoin de paralléliser tous tes chargements il faut soit plusieurs asynctask (ce qui rend la mise à jour de la progressbar plus complexe) soit passer par un ensemble de Thread (beaucoup plus de travail que de simple asynctask).

    Il faut aussi te demander si tu as vraiment besoin de tout initialiser dès la première activité. Ca ne sert à rien d'initialiser des choses qui ne seront utiliser que dans certaines activité par exemple. Autant le faire quand tu en as besoin.
    En règle général c'est désagréable de devoir attendre pour utiliser une application.
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  6. #6
    Membre régulier Avatar de vertebre
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2015
    Messages
    184
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2015
    Messages : 184
    Points : 111
    Points
    111
    Par défaut
    Bonsoir,


    L'intent service ou le service n'est à mon avis pas la solution dans ton cas.
    L'intent service est utilisé pour réaliser quelque chose en tache de fond , dont on à pas vraiment besoin de s'occuper.
    Merci de cette information.


    Il faut aussi te demander si tu as vraiment besoin de tout initialiser dès la première activité. Ca ne sert à rien d'initialiser des choses qui ne seront utiliser que dans certaines activité par exemple. Autant le faire quand tu en as besoin.
    Dans mon cas je fais une initialisation d'un objet profil utilisateur pour stocker ces informations en BDD distante, dans la SQLite, et certaines dans les préférences partagées.
    Toutes ces informations à une exception près seront utilisées par toutes les activitées, etc ...

    L'initialisation des objets de ma 1ere activité passe par plusieurs étapes :

    • vérifier la syntaxe des champs
    • vérifier si l'email existe en BDD distante (j'ai abandonné cette idée car je n'arrivais pas à enchainer avec le traitement suivant)
    • vérifier si l'email et le mdp concordent en BDD distante.


    Ces vérifications en BDD j'utilise Retrofit pour faire 2 call asynchrones.
    J'arrive à faire ces vérifications indépendamment et elles fonctionnent mais quand je veux les enchainer je n'y arrive pas.

    • Lorsque je passe de la vérification de la syntaxe à celle de l'email je dois cliquer 2 fois sur mon bouton
    • Lorsque je passe de la 1ere vérification à la 2eme oulàlà çà ne marche pas.



    Tu sembles plutôt vouloir faire attendre l'utilisateur avec un progressbar le temps du chargement :
    Du coup une ou plusieurs asyncTask me semble être plus judicieux.
    J'ai tenté de mettre mes 2 calls dans 2 asynctask séparées et les enchainés en faisant if (myTask.getStatus() == AsyncTask.Status.FINISHED) mais rien n'y fait le code s'execute d'un coup. J'ai tenté de mettre 2 calls asynchrones mais aussi 2 calls synchrones

    çà ne marche pas et je n'arrive pas à récupérer certains messages de debug que j'ai glisser dans mon code.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    bt_login.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View view) {
                // Show a progress spinner, and kick off a background task to
                // perform the user login attempt.
                //showProgress(true);
                Log.i("setOnClickListenner", "on est dans le setClickListenner, on va lançé attemp_Login_fORM");
     
                String result_email="";
                String result_emailMatchMdp="";
     
                attemptLogin_FORM(); // Handler verification des champs
     
                    if (isRightSyntaxBoth) {
                        //showProgress(true);
                            Log.i("setOnClickListenner", "attempLogin_FORM() vrai donc on execute le try");
                        // On vérifie si l'email existe
                        ProcessEmailExistTask processEmailExistTask = new ProcessEmailExistTask();
                            try {
                                Log.d("et_email.getText", et_email.getText().toString());
                                result_email = processEmailExistTask.execute(et_email.getText().toString()).get();
                                isEmailExist = Boolean.valueOf(result_email);
                                TimeUnit.SECONDS.sleep(4);
                                Log.d("reslut_email", result_email.toString());
                            }
                            catch (ExecutionException ee) {
                                Log.e("ProcessEmailExistTask", "Problème pour créer un coonverter :"+ ee.toString());
                            }
                            catch (Exception e) {
                                Log.e("ProcessEmailExistTask", "Erreur lors de la tache de verification de l'email --> "+e.toString());
                            }
     
                        if (processEmailExistTask != null && processEmailExistTask.getStatus() == AsyncTask.Status.FINISHED) {
                            //START YOUR NEW TASK HERE
                            Log.i("ProcessEmailExistTask", "ProcessEmailExistTask s'est terminé correctement");
                            Log.d("isEmailExistBefore", isEmailExist.toString());
                            if (isEmailExist)
                            { // si il existe on lance la deuxième asyntask
                                Log.d("isEmailExistAfter", isEmailExist.toString());
                                MyTaskParams params = new MyTaskParams(et_email.getText().toString(), et_password.getText().toString());
                                ProcessEmailMatchPwdTask processEmailMatchPwdTask = new ProcessEmailMatchPwdTask();
                                try {
                                    result_emailMatchMdp = processEmailMatchPwdTask.execute(params).get();
                                    isEmailMatchToPassword = Boolean.valueOf(result_emailMatchMdp);
                                }
                                catch (Exception e) {
                                    Log.e("ProcessEmailExistTask", "Erreur lors de la tache de verification de l'email --> "+e.toString());
                                }
                                // si l'email correspond au pass/
                                if (isEmailMatchToPassword)
                                {   // On redirige l'utilsateur
                                    // My AsyncTask is done and onPostExecute was called
                                    Log.i("AsyncTask_ProcessLogin", "ProcessLoginTask passed & all_result est à true");
                                    Intent registerIntent = new Intent(LoginActivityOld5.this, MainTabbedActivity.class);
                                    registerIntent.putExtra("Email", et_email.getText());
                                    registerIntent.putExtra("PwdHash", et_password.getText()); // A implémenter
                                    startActivity(registerIntent);
                                }
                                else
                                {
                                    Toast.makeText(LoginActivityOld5.this, "Vérifier vos identifiants", Toast.LENGTH_LONG).show();
                                    et_email.setError("email incorrect");
                                    et_password.setError("password incorrect");
                                    Log.i("setOnClickListenner", "Les identifiants ne concordent pas");
                                }
                            }
                            else
                            {
                                Toast.makeText(LoginActivityOld5.this, "L'email est incorrect", Toast.LENGTH_LONG).show();
                                et_email.setError("L'email n'existe pas");
                                Log.i("setOnClickListenner", "L'email n'existe pas");
     
                            }
                        }
                        else
                        {
                            //IGNORE BUTTON CLICK
                            Log.i("AsyncTask GetStatus()", "ProcessEmailExistTask est en cours ");
                        }
     
                    }
                    else
                    { // sinon on ne fait rien
                        showProgress(false);
                        Log.e("setOnClickListenner", "Le Bloc Try n'est pas exécuté : Valeur de isRightSyntaxBoth --> " + String.valueOf(isRightSyntaxBoth));
                    }
                }
            });

    D'autre part, ce qui m’embête aussi c'est que les asynctask sont des tâches asynchrones mais mes call Retrofit aussi sont asynchrones du coup je n'aurai pas besoin d'asynctask
    Un autre problème que j'ai rencontré aussi est que lorsque je cliquai sur mon bouton 'se connecter', une partie du traitement se faisait et je devais cliquer une 2eme fois pour continuer le traitement, du coup j'ai essayer de tous mettre à la suite dans le Listenner du bouton et çà marche.

    Dois je remettre mon handler pour verifier les champs ? pourrais tu critiquer stp ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
     bt_login.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View view) {
     
                    Log.i("setOnClickListenner", "on est dans le setClickListenner, on va lançé attemp_Login_fORM");
                    //showProgress(true);
     
                    // Reset errors.
                    et_email.setError(null);
                    et_password.setError(null);
     
                    // Store values at the time of the login attempt.
                    String email = et_email.getText().toString();
                    String password = et_password.getText().toString();
                    email_current = email;
                    password_current = password;
     
                    boolean cancel_email = false;
                    boolean cancel_password = false;
     
                    // Check Email syntaxe
                    // + Gérer le cas où l'email comporte un seule ou rien comme caractère
                    // On vérifie que le champ email_login n'est pas vide
                    if (TextUtils.isEmpty(email)) {
                        et_email.setError("Veuillez renseigner votre email svp");
                        et_email.setError("Champ requis.");
                        cancel_email = true;
                        isRightSyntaxEmail = false;
                        Log.i("Syntaxe email", "email vide");
                        focusView = et_email;
                    }
                    else if (!isEmailSyntaxValid(email)) {
                        et_email.setError("La syntaxe de l'email est incorrect");
                        cancel_email = true;
                        isRightSyntaxEmail = false;
                        Log.i("Syntaxe email", "Syntaxe email incorrect");
                        focusView = et_email;
                    }
                    else {
                        et_email.setError(null);
                        cancel_email = false;
                        isRightSyntaxEmail = true;
                        focusView = et_password;
                        Log.i("Syntaxe email", "Syntaxe email correct");
                    }
     
                    if (TextUtils.isEmpty(password)) {
                        et_password.setError("Veuillez renseigner votre mot de passe svp");
                        cancel_password = true;
                        isRightSyntaxPassword = false;
                        Log.i("Syntaxe password", "password vide");
                        focusView = et_password;
                    }
                    else if (!isPasswordSyntaxValid(password)) {
                        et_password.setError("La syntaxe du mot de passe est incorrect (8) A-Z, a-z, 0-9, @#-_");
                        Log.d("Syntaxe password", "Syntaxe password incorrect, le mauvais password entré est "+password);
                        cancel_password = true;
                        isRightSyntaxPassword = false;
                        focusView = et_password;
                    }
                    else {
                        et_password.setError(null);
                        cancel_password = false;
                        isRightSyntaxPassword = true;
                        focusView = null;
                        Log.i("Syntaxe password", "Syntaxe password correct");
                    }
     
                    // Si les champs sont incorrects et comportent des erreurs
                    if (cancel_email || cancel_password) {
     
                        isRightSyntaxBoth = false;
     
                        if (cancel_email) {
                            Log.d("email if(...)", "email comporte des erreurs");
                            focusView = et_email;
                        }
                        else if (cancel_password) {
                            Log.d("password if(...)", "password comporte des erreurs");
                            focusView = et_password;
                        }
                        else {
                            Log.e("cancel probleme", "probleme de variable boolean cancel");
                        }
                        //focusView.requestFocus();
     
                        Log.e("cancel Login_FORM()", "Il y a des erreurs dans la loginform(), cancel_email vaut --> "+String.valueOf(cancel_email)
                                +" cancel_password vaut --> "+String.valueOf(cancel_password));
     
                    }
     
                    else // les champs sont correct et ne comportent pas d'erreur
                    {
                        Log.d("onClickListenner", "if(isRightSyntaxBoth vaut true) La syntaxe des 2 champs est correct");
                        isRightSyntaxBoth = true;
     
                        Log.d("onClickListenner", "on lance le service rétrofit de concordance ");
                        Log.d("onClickListenner", "la valeur des paramètres sont email: "+email+" password : "+password);
     
                        // On fait notre CALL ProcessRTFIsEmailMatchToPassword(email, password);  // On lance le service retrofit pour verifier le couple
     
                        Log.d("CALL RETROFIT", "Le call retrofit est lançé");
                        // Create an instance own RestAdapter and of own Login API Service
                        LoginService.LoginApp_Service login_service = getComplexClient1(LoginActivity.this);
                        Log.d("email/mdp send to call", " email --> "+email+" password --> "+password);
                        Call<Integer> call = login_service.isEmailMatchToPassword(email, password);
                        call.enqueue(new Callback<Integer>() {
                            @Override
                            public void onResponse(Call<Integer> call, Response<Integer> response)
                            {
                                Log.d("PURE RESPONSE DATA", response.body().toString());
                                if (response.isSuccessful())
                                {
                                    Log.i("Retrofit EmailMatchPass", "On a bien reçu la requête du service retrofit isEmailMatchToPassword()");
     
                                    onResponseTest(response);
     
                                    if (response.body().equals(1))
                                    {
                                        Log.d("Sucess RESPONSE STR--> ", response.body().toString());
                                        isEmailMatchToPassword = true;
                                        Log.d("isEmailMatchToPassword", isEmailMatchToPassword.toString());
                                        editor.putBoolean("isEmailLoginMatchtoPwd", true);
                                        editor.commit();
                                        Log.d("onClickListenner", "if (isEmailMatchToPassword) L'email et pass concordent avec ceux en bdd");
                                        Intent intent = new Intent(LoginActivity.this, MainTabbedActivity.class);
                                        //registerIntegerent.putExtra("Email", et_email.getText());
                                        //registerIntegerent.putExtra("PwdHash", et_password.getText()); // A implémenter
                                        startActivity(intent);
                                    }
                                    else if (response.body().equals(0))
                                    {
                                        Log.d("Type/CLass OF response", response.body().getClass().toString());
                                        Log.d("Echec RESPONSE STR--> ", "response=false");
                                        isEmailMatchToPassword = false;
                                        Log.d("isEmailMatchToPassword", isEmailMatchToPassword.toString());
                                        editor.putBoolean("isEmailLoginMatchtoPwd", false);
                                        editor.commit();
                                        et_email.setError("identifiants incorrects");
                                        et_password.setError("identifiants incorrects");
                                    }
                                    else
                                    {
                                        Log.d("Type/CLass OF response", response.body().getClass().toString());
                                        Log.d("NULL RESPONSE STR--> ", "response=NULL");
                                        isEmailMatchToPassword = Boolean.valueOf(response.body().toString());
                                        Log.d("isEmailMatchToPassword", isEmailMatchToPassword.toString());
                                        Log.e("onClickListenner", "if (isEmailMatchToPassword) L'email et pass ne concordent pas avec ceux en bdd");
                                        editor.putBoolean("isEmailLoginMatchtoPwd", false);
                                        editor.commit();
     
                                    }
                                }
                                else
                                {
                                    // error response, no access to resource?
                                    isEmailMatchToPassword = false;
                                    Log.e("Call email match pass", "Pas de réponse, le service retrofit isEmailMatchToPassword() n'a pas accès aux ressources");
                                    onCallFinish();
                                }
                            }
     
                            @Override
                            public void onFailure(Call<Integer> call, Throwable t)
                            {
                                // something went completely south (like no Integerernet connection)
                                // java.io.EOFException response null
                                Log.e("ProcessEmail onFailure ", "une erreur s'est produite lors du call isEmailMatchToPassword -- > car onFailure() called"+t.toString());
                                if (t instanceof JsonEncodingException) {
                                    // pas de connexion Integerernet
                                    Log.e("onFailure ERROR", "Problème de JsonConverter--> " + t.toString());
                                }
                                if (t instanceof IOException) {
                                    Log.e("new except° non traitée", t.toString());
                                }
     
                                onCallFinish();
                            }
     
                            public void onResponseTest(Response<Integer> response) {
                                // On fait un traitement avec la reponse
                                Log.d("RESPONSE--> ", response.toString());
                                Log.d("RESPONSE-BODY--> ", response.body().toString());
                                Log.d("RESPONSE-BODY-STR--> ", response.body().toString());
                                Log.d("RESPONSE-HEADER--> ", response.headers().toString());
                                Log.d("RESPONSE-Integer--> ", response.message().toString());
                                //Log.d("RESPONSE-ERRORBODY--> ", response.errorBody().toString()); // Erreur !! ?
                                Log.d("RESPONSE-RAW--> ", response.raw().toString());
                            }
     
                            public void onCallFinish() {
                            }
                        });
     
     
                    }
     
     
                }
            });

    [..] soit passer par un ensemble de Thread (beaucoup plus de travail que de simple asynctask).
    J'ai regardé de ce coté pour essayer de structurer un peu les traitements que mon application lanceraient et, la mise en place de cet 'ensemble de thread' ou pas, était en partie une des raisons de mon post.
    Quand tu parles d'ensemble de thread, fais tu référence à un "système" (peut être ThreadPoolExecutor) qui me permette de lancer des threads indépendants et de les gérer avec une queue ?

    • Si c'est le cas, à partir de combien de taches asynchrones met on en place un tel système ?
    • J'avais pensé me pencher sur la mise en place de ce système pour décharger mes activités du code de ces traitements, est ce la solution pour décharger mes activités du code de ces traitements ?


    A propos des tâches asynchrones et synchrones, j'ai lu notamment sur les slideshare d'un membre de développez 'Mathias Seguy' de toujours être asynchrone.
    J'ai bien compris que Retrofit lance ces calls asynchrones dans un autre thread que l'UI et que l'AsyncTask aussi.
    Du coup, ce que je ne saisis pas c'est l'enchainement de tâche, lorsque l'on a besoin de faire un traitement (qui ne peut pas être fait depuis le thread UI) et de récupérer un résultat pour lancer un 2ème traitement.

    • Si je met 2 taches asynchrones à la suite(Retrofit ou AsyncTask) cela ne marchera pas car les 2 tâches se lancent en parallèles et ne s'attendent pas (même avec getStatus==finished pour les AsyncTask)
    • Si je fais 2 tâches synchrones (la 2eme est sensé attendre la 1ere), mais je devrai les mettre dans une autre thread que l'UI .. mais alors çà devient de l'asynchrone ?
    • Si je fais 2 taches synchrones Retrofit et que je les met dans 2 AsyncTask, cela transforme le synchrone en asynchrone aussi.


    Et pourtant j'ai lu la différence mais si le synchrone bloque le threadUI et que l'on déporte dans un autre thread, alors çà devient de l'asynchrone pourrais tu me redire quand utiliser de l'asynchrone et du synchrone stp ?

    Ces incompréhensions, incompétences ... (bref on peut en dire long) me plombent pour continuer mon application.


    Je crains de devoir encore m'excuser pour ce pavé,

    Bonne soirée à vous


    PS: En ce qui concerne les enchainements de call Retrofit, j'ai cru comprendre que je pourrais y parvenir avec RxJava, dois je pousser la dedans pour y parvenir ou ai je mal compris ?

  7. #7
    Modérateur
    Avatar de grunk
    Homme Profil pro
    Lead dév - Architecte
    Inscrit en
    août 2003
    Messages
    6 435
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Lead dév - Architecte
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 435
    Points : 18 772
    Points
    18 772
    Par défaut
    Je connais pas bien retrofit mais j'imagine que comme tous système faisant des requête asynchrones il y'a forcément un callback du genre onResponse() appelé à un moment pour dire que la requête est finie et récupérer son résultat.
    Si tu veux enchaîner plusieurs requêtes (et pas les faire en parallèle) il suffit donc de faire l'appel à la 2ème dans le callback de la première et ainsi de suite. C'est valable pour tous ce qui est asynchrone.

    Effectivement mettre un appel retrofit asynchrone dans une asynctask n'a aucun sens puisque l'asynctask va se terminer tout de suite.

    Quand tu parles d'ensemble de thread, fais tu référence à un "système" (peut être ThreadPoolExecutor) qui me permette de lancer des threads indépendants et de les gérer avec une queue ?
    Oui , après si tu as toujours besoin du même nombre de thread , tu as pas forcément besoin d'un Threadpool. Tu peux gérer manuellement X threads parce que ce sera toujours la même chose.

    Si c'est le cas, à partir de combien de taches asynchrones met on en place un tel système ?
    Il n'ya pas de règle.
    Je pars du principe que :
    - si l'action que je dois faire est simple et rapide => asynctask
    - Si c'est long , qu'il y'a beaucoup de traitement , et donc que la complexité d'écrire un thread est minimale par rapport au code métier => Thread

    Après si tu dois pop 10 asynctask c'est peut être mieux pour la clareté du code de passer par un thread pool , mais encore une fois pas de règle , c'est au feeling de chacun.

    pourrais tu me redire quand utiliser de l'asynchrone et du synchrone stp ?
    Ton affichage se fait à 60fps soit 16ms entre chaque itération.
    Si un traitement peut prendre plus de 16ms il devrait être asynchrone pour éviter une baisse de framerate. Dans les faits sur un application peu animée c'est pas très grave si on dépasse un peu puisque la baisse ne se resentira probablement pas.
    Mais tous les appels réseau doivent (forcé par le système) être asynchrone. Les appels à une bdd local devrait également l'être , bref tous ce qui peut être "long" doit être asynchrone
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  8. #8
    Membre régulier Avatar de vertebre
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2015
    Messages
    184
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2015
    Messages : 184
    Points : 111
    Points
    111
    Par défaut
    Si tu veux enchaîner plusieurs requêtes (et pas les faire en parallèle) il suffit donc de faire l'appel à la 2ème dans le callback
    mercii !!

    Pour ce qui est du synchrone, comme cela peut être bloquant et long pour les requêtes en BDD, quel est donc l’intérêt de "pouvoir"(pas de le faire) les placer en synchrone ? C'est une erreur au niveau de ma conception ?
    Peux tu me donner 1 ou 2 exemple de tâches synchrones stp ?

    bonne journée,

  9. #9
    Modérateur
    Avatar de grunk
    Homme Profil pro
    Lead dév - Architecte
    Inscrit en
    août 2003
    Messages
    6 435
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Lead dév - Architecte
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 435
    Points : 18 772
    Points
    18 772
    Par défaut
    Dans la grande majorité des cas les bdd utilisées dans les applis sont petites et ne contiennent pas beaucoup de données.
    C'est des cas de figure ou utiliser de l'asynchrone n'a pas de réel intérêt si ce n'est complexifier le code. Les requêtes s'executant en quelque ms on ne bloque pas le thread ui

    En revanche si on à beaucoup de requête à exécuter ou qu'elles sont importantes c'est judicieux de les faire en asynchrone.
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  10. #10
    Membre régulier Avatar de vertebre
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2015
    Messages
    184
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2015
    Messages : 184
    Points : 111
    Points
    111
    Par défaut
    J'ai pris note super

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Comment structurer une application avec des multiples versions ?
    Par Worldofdada dans le forum Windows Forms
    Réponses: 5
    Dernier message: 31/05/2007, 11h52
  2. Réponses: 8
    Dernier message: 21/05/2007, 22h40
  3. [Delphi.net]Structuration d'une application asp.net
    Par skywaukers dans le forum Delphi .NET
    Réponses: 7
    Dernier message: 28/12/2006, 12h50
  4. [Débutant] Require + Structure application PHP
    Par negri_l dans le forum Langage
    Réponses: 4
    Dernier message: 30/11/2006, 15h58
  5. [J2EE] Structurer une application J2EE
    Par trax020 dans le forum Java EE
    Réponses: 9
    Dernier message: 21/11/2005, 22h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo