blob: 307ffd1a9f8590314de72ec3d5ce692bdfb97b48 (
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
|
/*
* 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.*;
/**
* Represents a default implementation of <tt>OperationSetBasicTelephony</tt> in
* order to make it easier for implementers to provide complete solutions while
* focusing on implementation-specific details.
*
* @author Lubomir Marinov
*/
public abstract class AbstractOperationSetBasicTelephony
implements OperationSetBasicTelephony
{
/**
* Our class logger
*/
private static final Logger logger =
Logger.getLogger(AbstractOperationSetBasicTelephony.class);
/**
* A list of listeners registered for call events.
*/
private final List<CallListener> callListeners = new Vector<CallListener>();
/**
* Registers <tt>listener</tt> with this provider so that it
* could be notified when incoming calls are received.
*
* @param listener the listener to register with this provider.
*/
public void addCallListener(CallListener listener)
{
synchronized(callListeners)
{
if (!callListeners.contains(listener))
callListeners.add(listener);
}
}
/**
* Creates and dispatches a <tt>CallEvent</tt> notifying registered
* listeners that an event with id <tt>eventID</tt> has occurred on
* <tt>sourceCall</tt>.
*
* @param eventID the ID of the event to dispatch
* @param sourceCall the call on which the event has occurred.
*/
public void fireCallEvent(int eventID, Call sourceCall)
{
CallEvent cEvent = new CallEvent(sourceCall, eventID);
List<CallListener> listeners;
synchronized (callListeners)
{
listeners = new ArrayList<CallListener>(callListeners);
}
logger.debug("Dispatching a CallEvent to " + listeners.size()
+ " listeners. event is: " + cEvent);
for (Iterator<CallListener> listenerIter
= listeners.iterator(); listenerIter.hasNext();)
{
CallListener listener = listenerIter.next();
switch (eventID)
{
case CallEvent.CALL_INITIATED:
listener.outgoingCallCreated(cEvent);
break;
case CallEvent.CALL_RECEIVED:
listener.incomingCallReceived(cEvent);
break;
case CallEvent.CALL_ENDED:
listener.callEnded(cEvent);
break;
}
}
}
/**
* Removes the <tt>listener</tt> from the list of call listeners.
*
* @param listener the listener to unregister.
*/
public void removeCallListener(CallListener listener)
{
synchronized(callListeners)
{
callListeners.remove(listener);
}
}
/**
* Sets the mute state of the audio stream being sent to a specific
* <tt>CallPeer</tt>.
* <p>
* The default implementation does nothing.
* </p>
*
* @param peer the <tt>CallPeer</tt> who receives the audio
* stream to have its mute state set
* @param mute <tt>true</tt> to mute the audio stream being sent to
* <tt>peer</tt>; otherwise, <tt>false</tt>
*/
public void setMute(CallPeer peer, boolean mute)
{
/*
* While throwing UnsupportedOperationException may be a possible
* approach, putOnHold/putOffHold just do nothing when not supported so
* this implementation takes inspiration from them.
*/
}
}
|
