/**
* Processes the session initiation {@link SessionIQ} that we were created with, passing its
* content to the media handler and then sends either a "session-info/ringing" or a "terminate"
* response.
*
* @param sessionInitIQ The {@link SessionIQ} that created the session that we are handling here.
*/
protected synchronized void processSessionInitiate(SessionIQ sessionInitIQ) {
// Do initiate the session.
this.sessionInitIQ = sessionInitIQ;
this.initiator = true;
RtpDescriptionPacketExtension description = null;
for (PacketExtension ext : sessionInitIQ.getExtensions()) {
if (ext.getElementName().equals(RtpDescriptionPacketExtension.ELEMENT_NAME)) {
description = (RtpDescriptionPacketExtension) ext;
break;
}
}
if (description == null) {
logger.info("No description in incoming session initiate");
// send an error response;
String reasonText = "Error: no description";
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.INCOMPATIBLE_PARAMETERS,
reasonText);
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
try {
getMediaHandler().processOffer(description);
} catch (Exception ex) {
logger.info("Failed to process an incoming session initiate", ex);
// send an error response;
String reasonText = "Error: " + ex.getMessage();
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.INCOMPATIBLE_PARAMETERS,
reasonText);
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
// If we do not get the info about the remote peer yet. Get it right
// now.
if (this.getDiscoveryInfo() == null) {
String calleeURI = sessionInitIQ.getFrom();
retrieveDiscoveryInfo(calleeURI);
}
}
/**
* Start the swing notification service
*
* @param bc
* @throws java.lang.Exception
*/
public void start(BundleContext bc) throws Exception {
if (logger.isInfoEnabled()) logger.info("Swing Notification ...[ STARTING ]");
bundleContext = bc;
PopupMessageHandler handler = null;
handler = new PopupMessageHandlerSwingImpl();
getConfigurationService();
bc.registerService(PopupMessageHandler.class.getName(), handler, null);
if (logger.isInfoEnabled()) logger.info("Swing Notification ...[REGISTERED]");
}
/**
* Send Conference POST request to API endpoint which is used for allocating new conferences in
* reservation system.
*
* @param ownerEmail email of new conference owner
* @param mucRoomName full name of MUC room that is hosting the conference.
* {room_name}@{muc.server.net}
* @return <tt>ApiResult</tt> that contains system response. It will contain <tt>Conference</tt>
* instance filled with data from the reservation system if everything goes OK.
* @throws FaultTolerantRESTRequest.RetryExhaustedException When the number of retries to submit
* the request for the conference data is reached
* @throws UnsupportedEncodingException When the room data have the encoding that does not play
* with UTF8 standard
*/
public ApiResult createNewConference(String ownerEmail, String mucRoomName)
throws FaultTolerantRESTRequest.RetryExhaustedException, UnsupportedEncodingException {
Conference conference = new Conference(mucRoomName, ownerEmail, new Date());
HttpPost post = new HttpPost(baseUrl + "/conference");
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(1);
Map<String, Object> jsonMap = conference.createJSonMap();
for (Map.Entry<String, Object> entry : jsonMap.entrySet()) {
nameValuePairs.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
}
post.setEntity(new UrlEncodedFormEntity(nameValuePairs, "UTF8"));
logger.info("Sending post: " + jsonMap);
CreateConferenceResponseParser conferenceResponseParser =
new CreateConferenceResponseParser(conference);
FaultTolerantRESTRequest faultTolerantRESTRequest =
new FaultTolerantRESTRequest(post, conferenceResponseParser, retriesCreate, httpClient);
return faultTolerantRESTRequest.submit();
}
/**
* Should be called by consumer to obtain the object. It is causing hidden <tt>View</tt> to be
* displayed and eventually {@link #onObjectCreated(Object)} method to be called which results in
* object creation.
*
* @return provided object.
*/
public synchronized T obtainObject() {
ensureViewCreated();
if (this.providedObject == null) {
try {
logger.info("Waiting for object..." + hashCode());
this.wait(CREATE_TIMEOUT);
if (providedObject == null) {
throw new RuntimeException("Timeout waiting for surface");
}
logger.info("Returning object! " + hashCode());
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
return providedObject;
}
/**
* Blocks current thread until subject object is released. It should be used to block UI thread
* before the <tt>View</tt> is hidden.
*/
public synchronized void waitForObjectRelease() {
if (providedObject != null) {
try {
logger.info("Waiting for object release... " + hashCode());
this.wait(REMOVAL_TIMEOUT);
if (providedObject != null) {
throw new RuntimeException("Timeout waiting for preview surface removal");
}
logger.info("Object released! " + hashCode());
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
ensureViewDestroyed();
}
/**
* Handles registration of a new configuration form.
*
* @param event the <tt>ServiceEvent</tt> that notified us
*/
public void serviceChanged(ServiceEvent event) {
Object sService = AdvancedConfigActivator.bundleContext.getService(event.getServiceReference());
// we don't care if the source service is not a configuration form
if (!(sService instanceof ConfigurationForm)) return;
ConfigurationForm configForm = (ConfigurationForm) sService;
/*
* This AdvancedConfigurationPanel is an advanced ConfigurationForm so
* don't try to add it to itself.
*/
if ((configForm == this) || !configForm.isAdvanced()) return;
switch (event.getType()) {
case ServiceEvent.REGISTERED:
if (logger.isInfoEnabled())
logger.info("Handling registration of a new Configuration Form.");
this.addConfigForm(configForm);
break;
case ServiceEvent.UNREGISTERING:
this.removeConfigForm(configForm);
break;
}
}
/**
* Deletes conference from the reservation system.
*
* @param id identifier of the conference which has to be removed.
* @return one of {@link ReservationSystem} "result" constants.
*/
private int deleteConference(Number id) {
// Delete conference
try {
logger.info("Deleting conference: " + id);
ApiResult result = api.deleteConference(id);
if (result.getStatusCode() == 200) {
logger.info("Conference " + id + " deleted - OK");
return RESULT_OK;
} else {
logger.error("DELETE API ERROR: " + result);
}
} catch (FaultTolerantRESTRequest.RetryExhaustedException e) {
logger.error(e, e);
}
return RESULT_INTERNAL_ERROR;
}
/**
* Enables shutdown mode which means that no new focus instances will be allocated. After
* conference count drops to zero the process will exit.
*/
public void enableGracefulShutdownMode() {
if (!this.shutdownInProgress) {
logger.info("Focus entered graceful shutdown mode");
}
this.shutdownInProgress = true;
maybeDoShutdown();
}
/**
* Makes sure that conference is allocated for given <tt>room</tt>.
*
* @param room name of the MUC room of Jitsi Meet conference.
* @param properties configuration properties, see {@link JitsiMeetConfig} for the list of valid
* properties.
* @throws Exception if any error occurs.
*/
private void createConference(String room, Map<String, String> properties) throws Exception {
JitsiMeetConfig config = new JitsiMeetConfig(properties);
JitsiMeetConference conference =
new JitsiMeetConference(room, focusUserName, protocolProviderHandler, this, config);
conferences.put(room, conference);
StringBuilder options = new StringBuilder();
for (Map.Entry<String, String> option : properties.entrySet()) {
options.append("\n ").append(option.getKey()).append(": ").append(option.getValue());
}
logger.info(
"Created new focus for "
+ room
+ "@"
+ focusUserDomain
+ " conferences count: "
+ conferences.size()
+ " options:"
+ options.toString());
// Send focus created event
EventAdmin eventAdmin = FocusBundleActivator.getEventAdmin();
if (eventAdmin != null) {
eventAdmin.sendEvent(EventFactory.focusCreated(conference.getId(), conference.getRoomName()));
}
try {
conference.start();
} catch (Exception e) {
logger.info("Exception while trying to start the conference", e);
// stop() method is called by the conference automatically in order
// to not release the lock on JitsiMeetConference instance and avoid
// a deadlock. It may happen when this thread is about to call
// conference.stop() and another thread has entered the method
// before us. That other thread will try to call
// FocusManager.conferenceEnded, but we're still holding the lock
// on FocusManager instance.
// conference.stop();
throw e;
}
}
@Override
public void registrationStateChanged(RegistrationStateChangeEvent evt) {
RegistrationState registrationState = evt.getNewState();
logger.info("XMPP provider reg state: " + registrationState);
if (RegistrationState.REGISTERED.equals(registrationState)) {
// Do initializations which require valid connection
meetExtensionsHandler.init();
}
}
/**
* Process candidates received.
*
* @param sessionInitIQ The {@link SessionIQ} that created the session we are handling here
*/
public void processCandidates(SessionIQ sessionInitIQ) {
Collection<PacketExtension> extensions = sessionInitIQ.getExtensions();
List<GTalkCandidatePacketExtension> candidates = new ArrayList<GTalkCandidatePacketExtension>();
for (PacketExtension ext : extensions) {
if (ext.getElementName().equalsIgnoreCase(GTalkCandidatePacketExtension.ELEMENT_NAME)) {
GTalkCandidatePacketExtension cand = (GTalkCandidatePacketExtension) ext;
candidates.add(cand);
}
}
try {
getMediaHandler().processCandidates(candidates);
} catch (OperationFailedException ofe) {
logger.warn("Failed to process an incoming candidates", ofe);
// send an error response
String reasonText = "Error: " + ofe.getMessage();
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.GENERAL_ERROR,
reasonText);
getMediaHandler().getTransportManager().close();
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
// HACK for FreeSwitch that send accept message before sending
// candidates
if (sessAcceptedWithNoCands != null) {
if (isInitiator()) {
try {
answer();
} catch (OperationFailedException e) {
logger.info("Failed to answer call (FreeSwitch hack)");
}
} else {
final SessionIQ sess = sessAcceptedWithNoCands;
sessAcceptedWithNoCands = null;
// run in another thread to not block smack receive thread and
// possibly delay others candidates messages.
new Thread() {
@Override
public void run() {
processSessionAccept(sess);
}
}.start();
}
sessAcceptedWithNoCands = null;
}
}
/**
* Returns the <tt>URL</tt> of the image corresponding to the given key.
*
* @param urlKey The identifier of the image in the resource properties file.
* @return the <tt>URL</tt> of the image corresponding to the given key
*/
public URL getImageURL(String urlKey) {
String path = getImagePath(urlKey);
if (path == null || path.length() == 0) {
if (logger.isInfoEnabled()) logger.info("Missing resource for key: " + urlKey);
return null;
}
return getImageURLForPath(path);
}
/** {@inheritDoc} */
public synchronized Result createConference(String creator, String mucRoomName) {
Conference conference = conferenceMap.get(mucRoomName);
if (conference == null) {
// Create new conference
try {
ApiResult result = api.createNewConference(creator, mucRoomName);
if (result.getError() == null) {
conference = result.getConference();
conferenceMap.put(mucRoomName, conference);
} else if (result.getStatusCode() == 409 && result.getError().getConflictId() != null) {
Number conflictId = result.getError().getConflictId();
// Conference already exists(check if we have it locally)
conference = findConferenceForId(conflictId);
logger.info("Conference '" + mucRoomName + "' already " + "allocated, id: " + conflictId);
// do GET conflict conference
if (conference == null) {
ApiResult getResult = api.getConference(conflictId);
if (getResult.getConference() != null) {
conference = getResult.getConference();
// Fill full room name as it is not transferred
// over REST API
conference.setMucRoomName(mucRoomName);
conferenceMap.put(mucRoomName, conference);
} else {
logger.error("API error: " + result);
return new Result(RESULT_INTERNAL_ERROR, result.getError().getMessage());
}
}
} else {
// Other error
logger.error("API error: " + result);
return new Result(RESULT_INTERNAL_ERROR, result.getError().getMessage());
}
} catch (FaultTolerantRESTRequest.RetryExhaustedException e) {
logger.error(e, e);
return new Result(RESULT_INTERNAL_ERROR, e.getMessage());
} catch (UnsupportedEncodingException e) {
logger.error(e, e);
return new Result(RESULT_INTERNAL_ERROR, e.getMessage());
}
}
// Verify owner == creator
if (creator.equals(conference.getOwner())) {
return new Result(RESULT_OK);
} else {
logger.error(
"Room " + mucRoomName + ", conflict : " + creator + " != " + conference.getOwner());
return new Result(RESULT_CONFLICT);
}
}
/**
* Implements in order to listen for ended conferences and remove them from the reservation
* system.
*
* <p>{@inheritDoc}
*/
@Override
public synchronized void onFocusDestroyed(String roomName) {
// roomName = MucUtil.extractName(roomName);
// Focus destroyed
Conference conference = conferenceMap.get(roomName);
if (conference == null) {
logger.info("Conference " + roomName + " already destroyed");
return;
}
Result result = deleteConference(roomName);
if (result.getCode() == RESULT_OK) {
logger.info("Deleted conference from the reservation system: " + roomName);
} else {
logger.error("Failed to delete room: " + roomName + ", error code: " + result);
}
}
private void maybeDoShutdown() {
if (shutdownInProgress && conferences.size() == 0) {
logger.info("Focus is shutting down NOW");
ShutdownService shutdownService =
ServiceUtils.getService(FocusBundleActivator.bundleContext, ShutdownService.class);
shutdownService.beginShutdown();
}
}
/**
* Ends the call with for this <tt>CallPeer</tt>. Depending on the state of the peer the method
* would send a CANCEL, BYE, or BUSY_HERE message and set the new state to DISCONNECTED.
*
* @param failed indicates if the hangup is following to a call failure or simply a disconnect
* @param reasonText the text, if any, to be set on the <tt>ReasonPacketExtension</tt> as the
* value of its
* @param reasonOtherExtension the <tt>PacketExtension</tt>, if any, to be set on the
* <tt>ReasonPacketExtension</tt> as the value of its <tt>otherExtension</tt> property
*/
public void hangup(boolean failed, String reasonText, PacketExtension reasonOtherExtension) {
// do nothing if the call is already ended
if (CallPeerState.DISCONNECTED.equals(getState()) || CallPeerState.FAILED.equals(getState())) {
if (logger.isDebugEnabled())
logger.debug("Ignoring a request to hangup a call peer " + "that is already DISCONNECTED");
return;
}
CallPeerState prevPeerState = getState();
getMediaHandler().getTransportManager().close();
if (failed) setState(CallPeerState.FAILED, reasonText);
else setState(CallPeerState.DISCONNECTED, reasonText);
SessionIQ responseIQ = null;
if (prevPeerState.equals(CallPeerState.CONNECTED) || CallPeerState.isOnHold(prevPeerState)) {
responseIQ =
GTalkPacketFactory.createBye(getProtocolProvider().getOurJID(), peerJID, getSID());
responseIQ.setInitiator(isInitiator() ? getAddress() : getProtocolProvider().getOurJID());
} else if (CallPeerState.CONNECTING.equals(prevPeerState)
|| CallPeerState.CONNECTING_WITH_EARLY_MEDIA.equals(prevPeerState)
|| CallPeerState.ALERTING_REMOTE_SIDE.equals(prevPeerState)) {
responseIQ =
GTalkPacketFactory.createCancel(getProtocolProvider().getOurJID(), peerJID, getSID());
responseIQ.setInitiator(isInitiator() ? getAddress() : getProtocolProvider().getOurJID());
} else if (prevPeerState.equals(CallPeerState.INCOMING_CALL)) {
responseIQ =
GTalkPacketFactory.createBusy(getProtocolProvider().getOurJID(), peerJID, getSID());
responseIQ.setInitiator(isInitiator() ? getAddress() : getProtocolProvider().getOurJID());
} else if (prevPeerState.equals(CallPeerState.BUSY)
|| prevPeerState.equals(CallPeerState.FAILED)) {
// For FAILED and BUSY we only need to update CALL_STATUS
// as everything else has been done already.
} else {
logger.info("Could not determine call peer state!");
}
if (responseIQ != null) {
if (reasonOtherExtension != null) {
ReasonPacketExtension reason =
(ReasonPacketExtension)
responseIQ.getExtension(
ReasonPacketExtension.ELEMENT_NAME, ReasonPacketExtension.NAMESPACE);
if (reason == null) {
if (reasonOtherExtension instanceof ReasonPacketExtension) {
responseIQ.setReason((ReasonPacketExtension) reasonOtherExtension);
}
} else reason.setOtherExtension(reasonOtherExtension);
}
getProtocolProvider().getConnection().sendPacket(responseIQ);
}
}
/**
* Initializes this network address manager service implementation and starts all
* processes/threads associated with this address manager, such as a stun firewall/nat detector,
* keep alive threads, binding lifetime discovery threads and etc. The method may also be used
* after a call to stop() as a reinitialization technique.
*/
public void start() {
// init stun
String stunAddressStr = null;
int port = -1;
stunAddressStr = NetaddrActivator.getConfigurationService().getString(PROP_STUN_SERVER_ADDRESS);
String portStr = NetaddrActivator.getConfigurationService().getString(PROP_STUN_SERVER_PORT);
this.localHostFinderSocket = initRandomPortSocket();
if (stunAddressStr == null || portStr == null) {
useStun = false;
// we use the default stun server address only for chosing a public
// route and not for stun queries.
stunServerAddress = new StunAddress(DEFAULT_STUN_SERVER_ADDRESS, DEFAULT_STUN_SERVER_PORT);
logger.info(
"Stun server address("
+ stunAddressStr
+ ")/port("
+ portStr
+ ") not set (or invalid). Disabling STUN.");
} else {
try {
port = Integer.valueOf(portStr).intValue();
} catch (NumberFormatException ex) {
logger.error(portStr + " is not a valid port number. " + "Defaulting to 3478", ex);
port = 3478;
}
stunServerAddress = new StunAddress(stunAddressStr, port);
detector = new SimpleAddressDetector(stunServerAddress);
if (logger.isDebugEnabled()) {
logger.debug(
"Created a STUN Address detector for the following "
+ "STUN server: "
+ stunAddressStr
+ ":"
+ port);
}
detector.start();
logger.debug("STUN server detector started;");
// make sure that someone doesn't set invalid stun address and port
NetaddrActivator.getConfigurationService()
.addVetoableChangeListener(PROP_STUN_SERVER_ADDRESS, this);
NetaddrActivator.getConfigurationService()
.addVetoableChangeListener(PROP_STUN_SERVER_PORT, this);
// now start a thread query to the stun server and only set the
// useStun flag to true if it succeeds.
launchStunServerTest();
}
}
/**
* Starts the Metacafe replacement source bundle
*
* @param context the <tt>BundleContext</tt> as provided from the OSGi framework
* @throws Exception if anything goes wrong
*/
public void start(BundleContext context) throws Exception {
Hashtable<String, String> hashtable = new Hashtable<String, String>();
hashtable.put(
ReplacementService.SOURCE_NAME, ReplacementServiceMetacafeImpl.METACAFE_CONFIG_LABEL);
metacafeSource = new ReplacementServiceMetacafeImpl();
metacafeServReg =
context.registerService(ReplacementService.class.getName(), metacafeSource, hashtable);
logger.info("Metacafe source implementation [STARTED].");
}
/**
* Logs the specified message and details.
*
* @param message the message to log
* @param from the message sender
* @param to the message addressee
* @param status message status
* @param sender determines whether we are the origin of this message.
*/
public void logMessage(
SIPMessage message, String from, String to, String status, boolean sender) {
if (!logger.isInfoEnabled()) return;
String msgHeader;
if (sender) msgHeader = "JAIN-SIP sent a message from=\"";
else msgHeader = "JAIN-SIP received a message from=\"";
if (logger.isInfoEnabled())
logger.info(msgHeader + from + "\" to=\"" + to + "\" (status: " + status + "):\n" + message);
}
/** {@inheritDoc} */
public void start(BundleContext bc) throws Exception {
bundleContext = bc;
try {
logger.logEntry();
logger.info("Android notification handler Service...[ STARTED ]");
// Get the notification service implementation
ServiceReference notifReference =
bundleContext.getServiceReference(NotificationService.class.getName());
notificationService = (NotificationService) bundleContext.getService(notifReference);
vibrateHandler = new VibrateHandlerImpl();
notificationService.addActionHandler(vibrateHandler);
logger.info("Android notification handler Service...[REGISTERED]");
} finally {
logger.logExit();
}
}
/** Handles XEP-0337 "log" extensions. */
private void handleLogRequest(LogPacketExtension log, String jid) {
JitsiMeetConference conference = getConferenceForMucJid(jid);
if (conference == null) {
logger.debug("Room not found for JID: " + jid);
return;
}
Participant participant = conference.findParticipantForRoomJid(jid);
if (participant == null) {
logger.info("Ignoring log request from an unknown JID: " + jid);
return;
}
EventAdmin eventAdmin = FocusBundleActivator.getEventAdmin();
if (eventAdmin == null) return;
if (LogUtil.LOG_ID_PC_STATS.equals(log.getID())) {
String content = LogUtil.getContent(log);
if (content != null) {
ColibriConference colibriConference = conference.getColibriConference();
if (colibriConference != null) {
Event event =
EventFactory.peerConnectionStats(
colibriConference.getConferenceId(), participant.getEndpointId(), content);
if (event != null) eventAdmin.sendEvent(event);
} else {
logger.warn("Unhandled log request" + " - no valid Colibri conference");
}
}
} else if (logger.isInfoEnabled()) {
logger.info("Ignoring log request with an unknown ID:" + log.getID());
}
}
/**
* Makes sure that conference is allocated for given <tt>room</tt>.
*
* @param room name of the MUC room of Jitsi Meet conference.
* @param properties configuration properties, see {@link JitsiMeetConfig} for the list of valid
* properties.
* @throws Exception if any error occurs.
*/
private void createConference(String room, Map<String, String> properties) throws Exception {
JitsiMeetConfig config = new JitsiMeetConfig(properties);
JitsiMeetConference conference =
new JitsiMeetConference(room, focusUserName, protocolProviderHandler, this, config);
conferences.put(room, conference);
StringBuilder options = new StringBuilder();
for (Map.Entry<String, String> option : properties.entrySet()) {
options.append("\n ").append(option.getKey()).append(": ").append(option.getValue());
}
logger.info(
"Created new focus for "
+ room
+ "@"
+ focusUserDomain
+ " conferences count: "
+ conferences.size()
+ " options:"
+ options.toString());
// Send focus created event
EventAdmin eventAdmin = FocusBundleActivator.getEventAdmin();
if (eventAdmin != null) {
eventAdmin.sendEvent(EventFactory.focusCreated(conference.getId(), conference.getRoomName()));
}
try {
conference.start();
} catch (Exception e) {
logger.info("Exception while trying to start the conference", e);
conference.stop();
throw e;
}
}
/** Configures echo cancellation and noise suppression effects. */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
private void configureEffects() {
if (!AndroidUtils.hasAPI(16)) return;
AudioSystem audioSystem =
AudioSystem.getAudioSystem(AudioSystem.LOCATOR_PROTOCOL_AUDIORECORD);
// Creates echo canceler if available
if (AcousticEchoCanceler.isAvailable()) {
AcousticEchoCanceler echoCanceller =
AcousticEchoCanceler.create(audioRecord.getAudioSessionId());
if (echoCanceller != null) {
echoCanceller.setEnableStatusListener(this);
echoCanceller.setEnabled(audioSystem.isEchoCancel());
logger.info("Echo cancellation: " + echoCanceller.getEnabled());
}
}
// Automatic gain control
if (AutomaticGainControl.isAvailable()) {
AutomaticGainControl agc = AutomaticGainControl.create(audioRecord.getAudioSessionId());
if (agc != null) {
agc.setEnableStatusListener(this);
agc.setEnabled(audioSystem.isAutomaticGainControl());
logger.info("Auto gain control: " + agc.getEnabled());
}
}
// Creates noise suppressor if available
if (NoiseSuppressor.isAvailable()) {
NoiseSuppressor noiseSuppressor = NoiseSuppressor.create(audioRecord.getAudioSessionId());
if (noiseSuppressor != null) {
noiseSuppressor.setEnableStatusListener(this);
noiseSuppressor.setEnabled(audioSystem.isDenoise());
logger.info("Noise suppressor: " + noiseSuppressor.getEnabled());
}
}
}
/**
* Gets the list of features supported by participant. If we fail to obtain it due to network
* failure default feature list is returned.
*
* @param protocolProvider protocol provider service instance that will be used for discovery.
* @param address XMPP address of the participant.
*/
public static List<String> discoverParticipantFeatures(
ProtocolProviderService protocolProvider, String address) {
OperationSetSimpleCaps disco = protocolProvider.getOperationSet(OperationSetSimpleCaps.class);
if (disco == null) {
logger.error("Service discovery not supported by " + protocolProvider);
return getDefaultParticipantFeatureSet();
}
// Discover participant feature set
List<String> participantFeatures = disco.getFeatures(address);
if (participantFeatures == null) {
logger.error("Failed to discover features for " + address + " assuming default feature set.");
return getDefaultParticipantFeatureSet();
}
logger.info(address + ", features: ");
for (String feature : participantFeatures) {
logger.info(feature);
}
return participantFeatures;
}
/**
* Receives options requests and replies with an OK response containing methods that we support.
*
* @param requestEvent the incoming options request.
* @return <tt>true</tt> if request has been successfully processed, <tt>false</tt> otherwise
*/
@Override
public boolean processRequest(RequestEvent requestEvent) {
Response optionsOK = null;
try {
optionsOK =
provider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest());
// add to the allows header all methods that we support
for (String method : provider.getSupportedMethods()) {
// don't support REGISTERs
if (!method.equals(Request.REGISTER))
optionsOK.addHeader(provider.getHeaderFactory().createAllowHeader(method));
}
Iterable<String> knownEventsList = provider.getKnownEventsList();
synchronized (knownEventsList) {
for (String event : knownEventsList)
optionsOK.addHeader(provider.getHeaderFactory().createAllowEventsHeader(event));
}
} catch (ParseException ex) {
// What else could we do apart from logging?
logger.warn("Failed to create an incoming OPTIONS request", ex);
return false;
}
try {
SipStackSharing.getOrCreateServerTransaction(requestEvent).sendResponse(optionsOK);
} catch (TransactionUnavailableException ex) {
// this means that we received an OPTIONS request outside the scope
// of a transaction which could mean that someone is simply sending
// us b****hit to keep a NAT connection alive, so let's not get too
// excited.
if (logger.isInfoEnabled())
logger.info("Failed to respond to an incoming " + "transactionless OPTIONS request");
if (logger.isTraceEnabled()) logger.trace("Exception was:", ex);
return false;
} catch (InvalidArgumentException ex) {
// What else could we do apart from logging?
logger.warn("Failed to send an incoming OPTIONS request", ex);
return false;
} catch (SipException ex) {
// What else could we do apart from logging?
logger.warn("Failed to send an incoming OPTIONS request", ex);
return false;
}
return true;
}
/**
* The dependent service is available and the bundle will start.
*
* @param dependentService the UIService this activator is waiting.
*/
@Override
public void start(Object dependentService) {
if (logger.isDebugEnabled()) logger.debug("Update checker [STARTED]");
ConfigurationService cfg = getConfiguration();
if (OSUtils.IS_WINDOWS) {
updateService = new Update();
bundleContext.registerService(UpdateService.class.getName(), updateService, null);
// Register the "Check for Updates" menu item if
// the "Check for Updates" property isn't disabled.
if (!cfg.getBoolean(CHECK_FOR_UPDATES_MENU_DISABLED_PROP, false)) {
// Register the "Check for Updates" menu item.
CheckForUpdatesMenuItemComponent checkForUpdatesMenuItemComponent =
new CheckForUpdatesMenuItemComponent(Container.CONTAINER_HELP_MENU);
Hashtable<String, String> toolsMenuFilter = new Hashtable<String, String>();
toolsMenuFilter.put(Container.CONTAINER_ID, Container.CONTAINER_HELP_MENU.getID());
bundleContext.registerService(
PluginComponent.class.getName(), checkForUpdatesMenuItemComponent, toolsMenuFilter);
}
// Check for software update upon startup if enabled.
if (cfg.getBoolean(UPDATE_ENABLED, true)) updateService.checkForUpdates(false);
}
if (cfg.getBoolean(CHECK_FOR_UPDATES_DAILY_ENABLED_PROP, false)) {
logger.info("Scheduled update checking enabled");
// Schedule a "check for updates" task that will run once a day
int hoursToWait = calcHoursToWait();
Runnable updateRunnable =
new Runnable() {
public void run() {
logger.debug("Performing scheduled update check");
getUpdateService().checkForUpdates(false);
}
};
mUpdateExecutor = Executors.newSingleThreadScheduledExecutor();
mUpdateExecutor.scheduleAtFixedRate(
updateRunnable, hoursToWait, 24 * 60 * 60, TimeUnit.SECONDS);
}
if (logger.isDebugEnabled()) logger.debug("Update checker [REGISTERED]");
}
/**
* Parses JSON string returned in HTTP response and converts it to <tt>Conference</tt> instance.
*
* @param conference <tt>Conference</tt> instance that contains the data returned by API endpoint.
* @param response HTTP response returned by the API endpoint.
* @return <tt>Conference</tt> instance that contains the data returned by API endpoint.
* @throws IOException if any IO problems occur.
* @throws ParseException if any problems with JSON parsing occur.
*/
private Conference readConferenceResponse(Conference conference, HttpResponse response)
throws IOException, ParseException {
BufferedReader rd =
new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
if (conference != null) {
conferenceJson.setForUpdate(conference);
}
jsonParser.parse(rd, conferenceJson);
if (conference == null) {
conference = conferenceJson.getResult();
}
logger.info("ID: " + conference.getId());
logger.info("PIN: " + conference.getPin());
logger.info("URL: " + conference.getUrl());
logger.info("SIP ID: " + conference.getSipId());
logger.info("START TIME: " + conference.getStartTime());
logger.info("DURATION: " + conference.getDuration());
return conference;
}
/**
* Processes the session initiation {@link SessionIQ} that we were created with, passing its
* content to the media handler.
*
* @param sessionInitIQ The {@link SessionIQ} that created the session that we are handling here.
*/
public void processSessionAccept(SessionIQ sessionInitIQ) {
this.sessionInitIQ = sessionInitIQ;
CallPeerMediaHandlerGTalkImpl mediaHandler = getMediaHandler();
Collection<PacketExtension> extensions = sessionInitIQ.getExtensions();
RtpDescriptionPacketExtension answer = null;
for (PacketExtension ext : extensions) {
if (ext.getElementName().equalsIgnoreCase(RtpDescriptionPacketExtension.ELEMENT_NAME)) {
answer = (RtpDescriptionPacketExtension) ext;
break;
}
}
try {
mediaHandler.getTransportManager().wrapupConnectivityEstablishment();
mediaHandler.processAnswer(answer);
} catch (IllegalArgumentException e) {
// HACK for FreeSwitch that send accept message before sending
// candidates
sessAcceptedWithNoCands = sessionInitIQ;
return;
} catch (Exception exc) {
if (logger.isInfoEnabled()) logger.info("Failed to process a session-accept", exc);
// send an error response
String reasonText = "Error: " + exc.getMessage();
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.GENERAL_ERROR,
reasonText);
getMediaHandler().getTransportManager().close();
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
// tell everyone we are connecting so that the audio notifications would
// stop
setState(CallPeerState.CONNECTED);
mediaHandler.start();
}
/** implements BundleActivator.start() */
public void start(BundleContext bc) throws Exception {
logger.info("starting popup message test ");
bundleContext = bc;
setName("PopupMessageHandlerSLick");
Hashtable<String, String> properties = new Hashtable<String, String>();
properties.put("service.pid", getName());
// we maybe are running on machine without WM and systray
// (test server machine), skip tests
if (ServiceUtils.getService(bc, SystrayService.class) != null) {
addTest(TestPopupMessageHandler.suite());
}
bundleContext.registerService(getClass().getName(), this, properties);
}
/** {@inheritDoc} */
@Override
public synchronized void conferenceEnded(JitsiMeetConference conference) {
String roomName = conference.getRoomName();
conferences.remove(roomName);
logger.info(
"Disposed conference for room: " + roomName + " conference count: " + conferences.size());
if (focusAllocListener != null) {
focusAllocListener.onFocusDestroyed(roomName);
}
// Send focus destroyed event
FocusBundleActivator.getEventAdmin()
.sendEvent(EventFactory.focusDestroyed(conference.getId(), conference.getRoomName()));
maybeDoShutdown();
}