blob: eea2f3063e29b4d7d462ff58c3439f97b885c6be (
plain)
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
201
202
203
204
205
206
207
|
/*
* SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package net.java.sip.communicator.service.protocol;
import java.util.*;
import net.java.sip.communicator.service.protocol.event.*;
import net.java.sip.communicator.util.*;
/**
* An abstract implementation of the <tt>FileTransfer</tt> interface providing
* implementation of status and progress events related methods and leaving all
* protocol specific methods abstract. A protocol specific implementation could
* extend this class and implement only <tt>cancel()</tt> and
* <tt>getTransferredBytes()</tt>.
*
* @author Yana Stamcheva
*/
public abstract class AbstractFileTransfer
implements FileTransfer
{
private static final Logger logger =
Logger.getLogger(AbstractFileTransfer.class);
/**
* A list of listeners registered for file transfer status events.
*/
private Vector<FileTransferStatusListener> statusListeners
= new Vector<FileTransferStatusListener>();
/**
* A list of listeners registered for file transfer status events.
*/
private Vector<FileTransferProgressListener> progressListeners
= new Vector<FileTransferProgressListener>();
private int status;
/**
* Cancels this file transfer. When this method is called transfer should
* be interrupted.
*/
abstract public void cancel();
/**
* Returns the number of bytes already transfered through this file transfer.
*
* @return the number of bytes already transfered through this file transfer
*/
abstract public long getTransferedBytes();
/**
* Adds the given <tt>FileTransferProgressListener</tt> to listen for
* status changes on this file transfer.
*
* @param listener the listener to add
*/
public void addProgressListener(FileTransferProgressListener listener)
{
synchronized(progressListeners)
{
if(!progressListeners.contains(listener))
{
this.progressListeners.add(listener);
}
}
}
/**
* Adds the given <tt>FileTransferStatusListener</tt> to listen for
* status changes on this file transfer.
*
* @param listener the listener to add
*/
public void addStatusListener(FileTransferStatusListener listener)
{
synchronized(statusListeners)
{
if(!statusListeners.contains(listener))
{
this.statusListeners.add(listener);
}
}
}
/**
* Removes the given <tt>FileTransferProgressListener</tt>.
*
* @param listener the listener to remove
*/
public void removeProgressListener(FileTransferProgressListener listener)
{
synchronized(progressListeners)
{
this.progressListeners.remove(listener);
}
}
/**
* Removes the given <tt>FileTransferStatusListener</tt>.
*
* @param listener the listener to remove
*/
public void removeStatusListener(FileTransferStatusListener listener)
{
synchronized(statusListeners)
{
this.statusListeners.remove(listener);
}
}
/**
* Returns the current status of the transfer. This information could be
* used from the user interface to show a progress bar indicating the
* file transfer status.
*
* @return the current status of the transfer
*/
public int getStatus()
{
return status;
}
/**
* Notifies all status listeners that a new
* <tt>FileTransferStatusChangeEvent</tt> occured.
* @param newStatus the new status
*/
public void fireStatusChangeEvent(int newStatus)
{
this.fireStatusChangeEvent(newStatus, null);
}
/**
* Notifies all status listeners that a new
* <tt>FileTransferStatusChangeEvent</tt> occured.
* @param newStatus the new status
* @param reason the reason of the status change
*/
public void fireStatusChangeEvent(int newStatus, String reason)
{
// ignore if status is the same
if(this.status == newStatus)
return;
Collection<FileTransferStatusListener> listeners = null;
synchronized (statusListeners)
{
listeners
= new ArrayList<FileTransferStatusListener>(statusListeners);
}
if (logger.isDebugEnabled())
logger.debug("Dispatching a FileTransfer Event to" + listeners.size()
+ " listeners. Status=" + status);
FileTransferStatusChangeEvent statusEvent
= new FileTransferStatusChangeEvent(
this, status, newStatus, reason);
// Updates the status.
this.status = newStatus;
Iterator<FileTransferStatusListener> listenersIter
= listeners.iterator();
while (listenersIter.hasNext())
{
FileTransferStatusListener statusListener = listenersIter.next();
statusListener.statusChanged(statusEvent);
}
}
/**
* Notifies all status listeners that a new
* <tt>FileTransferProgressEvent</tt> occured.
* @param timestamp the date on which the event occured
* @param progress the bytes representing the progress of the transfer
*/
public void fireProgressChangeEvent(long timestamp, long progress)
{
Collection<FileTransferProgressListener> listeners = null;
synchronized (progressListeners)
{
listeners
= new ArrayList<FileTransferProgressListener>(progressListeners);
}
FileTransferProgressEvent progressEvent
= new FileTransferProgressEvent(this, timestamp, progress);
Iterator<FileTransferProgressListener> listenersIter
= listeners.iterator();
while (listenersIter.hasNext())
{
FileTransferProgressListener statusListener = listenersIter.next();
statusListener.progressChanged(progressEvent);
}
}
}
|
