action play/pause pour une copie de fichiers via socket

Bonjour,

Je dispose d'une application qui fait de la copie de fichier par des sockets java. J'ai du ajouter des progressBar pour indiquer le pourcentage, la vitesse... ça se passe bien, mais je voulais savoir si c'était possible, et de quelle manière, mettre en pause ce transfert.

Je dois ajouter un bouton play/pause pour la copie, et comme ça l'utilisateur peut bloquer/relancer la copie...

J'ai pas vraiment d'idée sur comment faire ça, puisqu'il y a deux traitements simultanés, un coté serveur, l'autre coté client.

quelles solutions peuvent être envisagées ?

Si je ne me trompe pas, je ne peux pas stopper le client, car le serveur va continuer a envoyer les fichiers normalement ?

je dois donc prévenir le serveur pour qu'il arrête d'envoyer des données et le synchroniser avec le client pour qu'il arrête de recevoir ?

si je chauffe ou que je refroidis dites le moi !

merci d'avance pour vos idées

Explique clairement le mode de communication...
Qui envoie le fichier : client ou serveur ?
Qui veut faire une pause : client ou serveur ?

merci de ta réponse,

le serveur envoie le fichier au client, le client voit sa barre de progression en fonction de cette réception, mais il peut mettre pause.

le fait de mettre pause doit bloquer la réception de fichier, donc le client doit mettre pause la réception. Le problème c'est que même si le client arrête de recevoir, le serveur continue a envoyer. Donc impossible de reprendre la copie ou elle en était.

Donc je SUPPOSE qu'il faut mettre en pause des deux cotés.

pour le mode, j'utilise les sockets java basiques donc en TCP.

Je poste le code pour info, mais ce n'est pas nécessaire, je veux surtout une méthode et non pas un bout de code !

je ne vois pas comment faire ça donc... en tout cas merci de t'y intéresser

voici le code qui envoie du coté serveur :

Code:

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
 
File f = new File(pathname);
 
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		BufferedOutputStream bos = new BufferedOutputStream(baos);
		OutputStream os = null;
 
		try {
			os = socket.getOutputStream();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
 
		int[] aecrire = new int[4096];
		int compteur = 0;
		long ouonestrendu = 0;
 
		int lu = -1;
 
		BufferedInputStream bis = null;
		try {
			bis = new BufferedInputStream(new FileInputStream(f));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
 
		try {
			lu = bis.read();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		//Tant qu'on est pas à la fin fu chier
		while(lu > -1) {
 
			//	On lit les données du fichier
			aecrire[compteur] = lu;
			try {
				lu = bis.read();
			} catch (IOException e) {
				e.printStackTrace();
			}
			compteur++;
 
			//Quand on a rempli le tableau, on envoie un paquet de 4096 octets
			if(compteur == 4096){
 
				compteur=0;
				ouonestrendu++;
				//		On remplit le tampon
 
				for(int x=0;x<4096;x++){
					try {
						bos.write(aecrire[x]);
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
 
				//	Et on l'envoie
				try {
					os.write(baos.toByteArray());
				} catch (IOException e) {
					e.printStackTrace();
				}
 
				baos.reset();
			}
		}
 
		//On envoie le dernier paquet, qui ne fait pas forcément 4096 octets
		//		On remplit le tampon
		for(int x=0 ; x<compteur ; x++){
			try {
				bos.write(aecrire[x]);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
 
		//Et on l'envoie
		try {
 
			bos.flush();
			os.write(baos.toByteArray());
			os.flush();
 
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		System.out.println("Youpi finished");
 
		try {
 
			bos.close();
			baos.close();
 
		} catch (IOException e) {
			e.printStackTrace();
		}

voici le code qui recoit coté client

Code:

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
 
FileOutputStream out = null;
BufferedOutputStream outBuffer = null;
 
try {
	out = new FileOutputStream("/home/ginko/" + nomVideo);
	inBuffer = new BufferedInputStream(socket.getInputStream());
	outBuffer = new BufferedOutputStream(out);
} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (Exception e) {
	e.printStackTrace();
}
 
int ratioFichier = tailleFichier / 100;
int ratioGeneral = tailleTotaleFichiers / 100;
 
while(enCours){
 
	try {
		lu = inBuffer.read();
		outBuffer.write(lu);
	} catch (IOException e) {
		System.out.println("erreur coupure connexion");
		return -1;
	}
 
	cptTailleFichier++;
	cptTailleGeneral++;
 
	if (cptTailleFichier%ratioFichier == 0){
 
		gcFichierFin = new GregorianCalendar();
		long millFichierFin = gcFichierFin.getTimeInMillis();
		long tpsEntreDeux = millFichierFin-milliFichierDeb;
		gcFichierDeb = new GregorianCalendar();
		milliFichierDeb = gcFichierDeb.getTimeInMillis();
		int moins 		 = 100-pourCentFichier;
 
                pourCentFichier++;
	        pourCentTotal--;
	}
 
	if (cptTailleGeneral%ratioGeneral == 0){
 
		gcTotalFin = new GregorianCalendar();
		long milliTotalFin = gcTotalFin.getTimeInMillis();
		long tpsEntreDeux = milliTotalFin-milliTotalDeb;
		gcTotalDeb = new GregorianCalendar();
		milliTotalDeb = gcTotalDeb.getTimeInMillis();
 
		/* le fichier courant vient de se terminer */
		if (cptTailleFichier == tailleFichier){
	             	/* on precise que la lecture du fichier est terminee */
			enCours = false;
		}
	}
 
	/* fermeture des flux */
	try {
        	outBuffer.flush();
	        outBuffer.close();
		out.flush();
		out.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}