Discussion :

[vertebre]

Bonsoir,

J'ai un objet A qui subit la fonction1 d'un objet B pour un temps donné, les attributs de l'objet A sont donc modifiés.
Une fois le temps arrivé à 0, j'applique une fonction2 qui réaffecte les valeurs initiales de l'objet A (fonction inverse de la fonction1).

voilà comment je compte concevoir ce truc:

-variable contenant le temps d'affectation de la fonction1 (120mn par exemple)
-à l'activation de l'objet B, on commence le décompte des 120mn
-une fois le décompte arrivé à 0, on affecte la fonction2.

Est ce la meilleur façon de voir les choses et comment faire et afficher ce décompte horaire en java svp ?

Bonne soirée,

[joel.drigo]

Salut,

Déjà, il faut que tu définisses "affichage" : affiche où/comment ? En console ? Dans une fenêtre Swing ? Et puis que veux tu afficher ? Le décompte, c'est en minutes, en minutes/secondes... ?

Ensuite, à la base, tu peux utiliser la classe java.util.Timer et sa méthode scehdule() pour lancer la tâche de remise à zéro (attention le temps s'exprime en millisecondes. Si tu veux pouvoir afficher le décompte intermédiaire, quelque soit l'unité, cette méthode ne peux pas fonctionner directement : on programme la tâche et elle s'exécute lorsque le délai est achevé. On pourrait faire un thread qui boucle, jusqu'à ce que le temps soit achevé, et qui, sur une condition intermédiaire met à jour un affichage, du type :

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
tempstotal = 120 * 60 * 1000
tempsrestant = tempstotal
tempsdepart = System.currentTimeMillis()
tempsinter = temps
tempsactuel
tant que (tempactuel = System.currentTimeMillis())-tempsdepart < tempstotal
si tempactuel - tempsinter > 1000  // pour un décompte seconde par seconde (1000 ms)
   tempinter = tempsactuel
   tempsrestant  = tempsactuel - tempsdepart
   mettre à jour affichage décompte tempsrestant 
fin si
fin tant que

Ce n'est pas hyper précis, puisque l'exécution de ce code mets lui même du temps, mais ça peut le faire si tu n'as pas besoin de grande précision.

Tu peux également procéder avec deux java.util.Timer : un pour programmer la tâche de remise à zéro, et un qui décompte le temps (en utilisant la méthode scheduleAtFixedRate()). Le premier devra aussi arrêter le second (méthode cancel()).

[vertebre]

Bonjour,

Le programme doit afficher le décompte dans une appli android, je pense choisir çà dans un textview.

Je voudrais un affichage de ce type:
1mn 59sec
1mn 58sec
1mn 57sec
...

Mais comme c'est un jeu j'ai besoin d'une précision relative. En effet si une personne utilise ce décompte sur un tel puissant celui ci durera moins longtemps que sur un téléphone moins puissant.
J'ai donc besoin soit d'une manière de mesurer le temps d'exécution de ce code en fonction de la machine, puis adapter le décompte et homogénéiser le temps de décompte sur les téléphones différents; soit d'une autre façon.

Qu'en penses tu ? vois tu une autre manière de voir ce problème ?

[joel.drigo]

Mais comme c'est un jeu j'ai besoin d'une précision relative. En effet si une personne utilise ce décompte sur un tel puissant celui ci durera moins longtemps que sur un téléphone moins puissant.
J'ai donc besoin soit d'une manière de mesurer le temps d'exécution de ce code en fonction de la machine, puis adapter le décompte et homogénéiser le temps de décompte sur les téléphones différents; soit d'une autre façon.

Non, c'est utopique de raisonner comme ça. Le temps de faire des adaptations en fonction de je sais pas quoi, temps qui dépend lui-même de plein de choses (vitesse du processeur, disponibilité des ressources, priorité des processus, etc), il faudra lui-même l'adapter, et donc prendre du temps, donc l'adapter etc.
Il n'y a pas de raison que le décompte soit différent selon l'appareil (le temps total d'exécution d'une tâche oui, le temps de rafraîchissement effectivement).

Le temps (en dépit de son aspect relatif que nous négligerons pour des raisons évidentes...) doit être considéré comme absolu dans ce type de calcul et surtout indépendant de ce qu'on fait comme tâche : ainsi, que ça prenne un retard ou une avance, lors d'un affichage, on s'en moque, parce que chaque affichage est traité de manière absolue (par rapport au début du processus, de ce qui a été déjà fait, et de ce qu'il reste à faire), et le temps de toute manière de rafraîchir l'affichage, tous les ajustements que tu pourras faire seront de toute façon caduques. Le but est d'éviter surtout les aberrations (dire qu'il reste une heure à attendre alors qu'il reste 1 seconde).

Par exemple, si le but est de faire un affichage de temps restant de transfert d'un fichier, on peut calculer ou estimer un nombre total d'octets à transférer, calculer régulièrement le temps depuis le début, en déduire la vitesse de traitement de chaque octet (ou groupe d'octets), à partir de la différence entre ce qui a été fait et ce qui doit être fait, déterminer le reste à faire, puis en déduire le temps restant, qui sera forcément une approximation, mais ça n'a normalement pas grande importance humainement on fait pas trop la différence et on s'en fout à la limite, à moins qu'on ait besoin d'une très grand précision dans un domaine très particulier (scientifique, genre astrophysique, ou vol spatial ), mais là, ça risque d'être plutôt complexe à garantir). Le calcul peut-être fait en parallèle, pour éviter d'influencer le temps d'exécution de la tâche principale (l'affichage lui étant forcément asynchrone).

[vertebre]

En gros si j'ai bien compris tu me conseille de lancer vérifier régulièrement le temps restant par rapport à l'horaire où la tâche est lancée ? pour adapter le décompte si vraiment il y a un très gros écart ?

[joel.drigo]

Il n'y a rien à vérifier : tu lances une tâche avec un délai de 120 minutes, et une autre avec une certaine fréquence (toutes les secondes si tu veux faire un décompte à la seconde) qui affiche le décompte, en comparant éffectivement le moment de départ de la tâche par rapport au moment actuel.

tâche de démarrage

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
programmer tâche principale avec un délai de 120 minutes (java.util.Timer)
temps cible = temps actuel + 120 minutes
lancer tâche décompte avec un délai de 1 seconde et une fréquence de 1 secondes (java.util.Timer)

tâche décompte

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
décompte = temps cible - temps actuel
si décompte<= 0 s'arrêter
afficher décompte

tâche principale

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
arrêter tâche 2
...faire ce qu'on veut