Discussion :

[borozhim]

Bonjour,

Je suis actuellement en train de développer une application graphique.
Dans cette appli, j'ai besoin de dézipper un certain nombre de fichiers.
J'aimerais permettre à l'utilisateur de connaitre (dans l'idéal) le temps restant avant la fin du dézippage,
ou plus simplement le pourcentage restant ou le nombre d'octets restant ... bref une info qui permettrait à l'utilsateur d'évaluer le temps de traitement restant !

Je sollicite donc votre aide.

Mes questions sont donc les suivantes :
Est-il possible, avec la méthode que j'utilise et avec seulement l'API Zip fournie dans Java (java.util.zip), d'obtenir une indication sur le temps de traitement restant ?
Si oui, pouvez-vous m'orienter vers la solution ?

Je précise que j'ai déjà mis en place le mécanisme me permettant de mettre à jour une barre de progression en fonction de l'avancement, il ne me manque que les infos "xxx total" et "xxx restant"
Mon problème ne concerne donc pas l'aspect graphique.

J'ai déjà recherché parmi les méthodes de ZipEntry, ZipFile et ZipInputStream, mais à part connaitre la taille de l'archive, je n'ai rien trouvé ^^'

Ci-dessous la méthode que j'utilise pour dézipper un fichier :

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
 
private final void unzip(final String fichier) throws InterruptedException, IOException {
 
        // Variables locales
        BufferedOutputStream dest = null;
        BufferedInputStream is = null;
        ZipEntry entry;
        final ZipFile zipfile = new ZipFile(fichier);
        final Enumeration<? extends ZipEntry> e = zipfile.entries();
        String cheminFichierOut;
        File fichierOut;
        byte[] data;
        int count = 0;
        FileOutputStream fos;
 
        // Tant qu'il reste des éléments à dézipper
        while (e.hasMoreElements()) {
 
            // Récupère l'élément
            entry = e.nextElement();
 
            // Puis le nom de l'élément à dézipper
            cheminFichierOut = fichier.substring(0, fichier.lastIndexOf('\\') + 1) + entry.getName();
 
            fichierOut = new File(cheminFichierOut);
 
            // Si le fichier n'est pas déjà présent
            if (!fichierOut.exists()) {
 
                is = new BufferedInputStream(zipfile.getInputStream(entry));
 
                // On utilise 1 bloc try ... finally pour chaque ressource afin d'être sur que chacune sera libérée, même en cas d'exception
                try {
 
                    data = new byte[UnZipper.BUFFER];
 
                    fos = new FileOutputStream(cheminFichierOut);
 
                    try {
 
                        dest = new BufferedOutputStream(fos, UnZipper.BUFFER);
 
                        try {
 
                            // Ecriture
                            while ((count = is.read(data, 0, UnZipper.BUFFER)) != -1) {
 
                                this.testInterruption();
                                dest.write(data, 0, count);
 
                            }
 
                        } finally {
 
                            dest.flush();
                            dest.close();
 
                        }
 
                    } finally {
 
                        fos.close();
 
                    }
 
                } finally {
 
                    is.close();
 
                }
 
            }
 
        }
 
    }

J'espère que quelqu'un saura me renseigner.

Merci d'avance à ceux qui se pencheront sur mon problème.

N'hésitez pas à me poser des questions si vous jugez qu'il vous manque des infos.

Cordialement
Vincent Daniel

[tchize_]

a part parcourir la liste des énumérations une fois pour les compter avant de faire le travail d'extraction, je vois pas

[thebloodyman]

Salut !

Petite proposition :

Avant la décompression, tu récupères la taille du fichier à décompresser :

Code :

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

1
2
3
 
File fileToDecompress = new File("blabla.zip");
int tailleTotaleArchive = fileToDecompress .length()

Ensuite pendant le traitement de décompression, pour chaque ZipEntry sur lequel tu itérés, utilise la méthode getCompressedSize() de la classe ZipEntry qui te donnera la taille de l'entrée.
A chaque zipEntry décompressée, tu as un état d'avancement en sommant la taille de toutes les entrées traitées que tu diviseras par la taille totale de l'archive récupéré au début.

[borozhim]

Merci à vous deux pour vos propositions !

En effet, j'ai pensé à ta solution thebloodyman, mais j'avais besoin de quelque chose d'assez précis.

J'ai donc utilisé ce que proposait tchize_, je parcours dans un premier temps l'énumération :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
zipfile = new ZipFile(fichierIn);
enumeration = zipfile.entries();
 
while (enumeration.hasMoreElements()) {
 
     // Récupère la taille décompressée de l'élément
     octetsADecompresser += enumeration.nextElement().getSize();
 
}

Dans ma méthode qui permet de dézipper, je mets à jour un compteur pour connaitre le nombre d'octets déjà décompressés :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
// Ecriture
while ((count = is.read(data, 0, BUFFER)) != -1) {
 
     dest.write(data, 0, count);
     octetsDecompresses += count;
 
     // Met à jour la progression
     ...
 
}

Au passage, j'en profite pour ajouter la solution que j'ai trouvé pour réaliser la même chose avec un GZip (mon appli gère les deux).

Pour connaitre la taille d'un GZip, c'est plus compliqué que pour un Zip car il n'y a pas d'objet équivalent à des ZipFile ou ZipEntry dans le cas d'un GZip. J'ai utilisé la solution trouvée ici : Connaitre la taille après décompression d'un GZip


Merci à vous, c'est résolu.