Migration vers Ntro v10 #

Problème: une tâche modified ne s’exécute pas toujours du premier coup #

Le problème affecte principalement:

• Le mode client/serveur

• Avec les collections, p.ex. modified(ModeleFoo.class, idVersion)

• La première fois que la page s’affiche

  • NOTES:
    • après une action usager, la page fonctionne normalement
    • (une nouvelle observation est envoyée au client et le modified s’exécute)

Solution de contournement: forcer le dorsal à ré-envoyer une observation #

1. Créer un message du genre MsgDeclencherObservation

2. Dans le dorsal, ajouter une tâche qui

   • waitsFor le modèle a rafraîchir

   • waitsFor le message

   • p.ex.

     public static void creerTaches(BackendTasks tasks, String idVersion) {
                 declencherObservation(tasks, idVersion);
     
                 // ...
             }
     
             private static void declencherObservation(BackendTasks tasks, String idVersion) {
                 tasks.task("declencherObservation")
     
                      .waitsFor(model(ModeleFileAttente.class, idVersion))
     
                      .waitsFor(message(MsgDeclencherObservation.class, idVersion))
     
                      .executes(inputs -> {
     
                          // rien à faire; une observation est envoyée
                          // automatiquement après l'exécution de la
                          // tâche
     
                      });
             }
     

3. Dans le frontal, envoyer le message avant d’afficher

   • dès le début:

     public class FrontalPong implements FrontendFx {
     
                 // ...
     
                 @Override
                 public void execute() {
     
                     Ntro.newMessage(MsgDeclencherObservation.class, MaquetteSession.idVersion).send();
     
                 }
     

   • et/ou lors de la navigation:

     public class Navigation {
     
                 public static void creerTaches(FrontendTasks tasks) {
     
                     tasks.taskGroup("Navigation")
     
                          .waitsFor("Initialisation")
     
                          .andContains(subTasks -> {
     
                              afficherVueFileAttente(subTasks);
     
                              // ...
     
                          });
                 }
     
                 // ...
     
                 private static void afficherVueFileAttente(FrontendTasks tasks) {
     
                     tasks.task("afficherVueFileAttente")
     
                           .waitsFor(created(VueFileAttente.class))
     
                           .waitsFor(event(EvtAfficherFileAttente.class))
     
                           .thenExecutes(inputs -> {
     
                               VueRacine      vueRacine      = inputs.get(created(VueRacine.class));
                               VueFileAttente vueFileAttente = inputs.get(created(VueFileAttente.class));
     
                               vueRacine.afficherSousVue(vueFileAttente);
     
                               Ntro.newMessage(MsgDeclencherObservation.class, MaquetteSession.idVersion).send();
                           });
                 }
             }
     

Autre solution: migration à v10 #

Je pense avoir réglé le problème, qui était lié au délai de connexion au serveur (le frontal commençait à s’exécuter en mode local en attendant la connexion, ce qui n’est pas le comportement désiré).

Pour migrer à v10:

1. Modifier gradle.properties et s’assurer d’avoir:

   version=v10
   

2. Re-créer les projets VSCode

   $ sh scripts/ajouter_atelier.sh
   

   • NOTES:
     • c’est normal d’avoir BUILD FAILED
     • continuer les étapes ci-bas pour corriger les erreurs

Comme pour v09: remplacer drawOn par drawOnWorld #

• drawOn(ResizableWorld2dCanvasFx convas) doit devenir drawOnWorld(GraphicsContext gc)

  public class Palette2d extends ObjetPong2d {
  
          @Override
          // modifier
          // public void drawOn(ResizableWorld2dCanvasFx canvas) {
          // pour devenir:
          public void drawOnWorld(GraphicsContext gc) {
  
              // retirer
              //canvas.drawOnWorld(gc -> {
  
                  gc.save();
  
  
                  gc.fillRect(getTopLeftX(),
                              getTopLeftY(),
                              getWidth(), 
                              getHeight());
  
                  gc.restore();
  
              // retirer
              //});
          }