/**
* Put the JAIN-SIP stack in a state where it cannot receive any data and frees the network ports
* used. That is to say remove JAIN-SIP <tt>ListeningPoint</tt>s and <tt>SipProvider</tt>s.
*/
@SuppressWarnings("unchecked") // jain-sip legacy code
private void stopListening() {
try {
this.secureJainSipProvider.removeSipListener(this);
this.stack.deleteSipProvider(this.secureJainSipProvider);
this.secureJainSipProvider = null;
this.clearJainSipProvider.removeSipListener(this);
this.stack.deleteSipProvider(this.clearJainSipProvider);
this.clearJainSipProvider = null;
Iterator<ListeningPoint> it = this.stack.getListeningPoints();
Vector<ListeningPoint> lpointsToRemove = new Vector<ListeningPoint>();
while (it.hasNext()) {
lpointsToRemove.add(it.next());
}
it = lpointsToRemove.iterator();
while (it.hasNext()) {
this.stack.deleteListeningPoint(it.next());
}
this.stack.stop();
if (logger.isTraceEnabled()) logger.trace("stopped listening");
} catch (ObjectInUseException ex) {
logger.fatal("Failed to stop listening", ex);
}
}
/**
* When a message is received determines whether to open a new chat window or chat window tab, or
* to indicate that a message is received from a contact which already has an open chat. When the
* chat is found checks if in mode "Auto popup enabled" and if this is the case shows the message
* in the appropriate chat panel.
*
* @param evt the event containing details on the received message
*/
public void messageReceived(MessageReceivedEvent evt) {
if (logger.isTraceEnabled())
logger.trace("MESSAGE RECEIVED from contact: " + evt.getSourceContact().getAddress());
Contact protocolContact = evt.getSourceContact();
ContactResource contactResource = evt.getContactResource();
Message message = evt.getSourceMessage();
int eventType = evt.getEventType();
MetaContact metaContact =
GuiActivator.getContactListService().findMetaContactByContact(protocolContact);
if (metaContact != null) {
messageReceived(
protocolContact,
contactResource,
metaContact,
message,
eventType,
evt.getTimestamp(),
evt.getCorrectedMessageUID(),
evt.isPrivateMessaging(),
evt.getPrivateMessagingContactRoom());
} else {
if (logger.isTraceEnabled())
logger.trace("MetaContact not found for protocol contact: " + protocolContact + ".");
}
}
/**
* Removes the group created in the server stored contact list by the create group test, makes
* sure that the corresponding event has been generated and verifies that the group is not in the
* list any more.
*/
public void postTestRemoveGroup() {
logger.trace("testing removal of server stored groups");
// first add a listener
GroupChangeCollector groupChangeCollector = new GroupChangeCollector();
opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector);
try {
// remove the group
opSetPersPresence1.removeServerStoredContactGroup(
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2));
} catch (OperationFailedException ex) {
logger.error("error removing group", ex);
}
groupChangeCollector.waitForEvent(10000);
opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector);
// check whether we got group created event
assertEquals("Collected Group Change event", 1, groupChangeCollector.collectedEvents.size());
assertEquals(
"Group name.",
testGroupName2,
((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0))
.getSourceGroup()
.getGroupName());
// check whether the group is still on the contact list
ContactGroup group =
opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2);
assertNull("A freshly removed group was still on the contact list.", group);
}
/**
* Adds this <tt>listener</tt> as a candidate recipient for the dispatching of new messages
* received from the JAIN-SIP <tt>SipProvider</tt>s.
*
* @param listener a new possible target for the dispatching process.
* @throws OperationFailedException if creating one of the underlying <tt>SipProvider</tt>s fails
* for whatever reason.
*/
public void addSipListener(ProtocolProviderServiceSipImpl listener)
throws OperationFailedException {
synchronized (this.listeners) {
if (this.listeners.size() == 0) startListening();
this.listeners.add(listener);
if (logger.isTraceEnabled()) logger.trace(this.listeners.size() + " listeners now");
}
}
/**
* This <tt>listener</tt> will no longer be a candidate recipient for the dispatching of new
* messages received from the JAIN-SIP <tt>SipProvider</tt>s.
*
* @param listener possible target to remove for the dispatching process.
*/
public void removeSipListener(ProtocolProviderServiceSipImpl listener) {
synchronized (this.listeners) {
this.listeners.remove(listener);
int listenerCount = listeners.size();
if (logger.isTraceEnabled()) logger.trace(listenerCount + " listeners left");
if (listenerCount == 0) stopListening();
}
}
/**
* Place to put some hacks if needed on incoming requests.
*
* @param event the incoming request event.
* @return status <code>true</code> if we don't need to process this message, just discard it and
* <code>false</code> otherwise.
*/
private boolean applyNonConformanceHacks(RequestEvent event) {
Request request = event.getRequest();
try {
/*
* Max-Forwards is required, yet there are UAs which do not
* place it. SipProvider#getNewServerTransaction(Request)
* will throw an exception in the case of a missing
* Max-Forwards header and this method will eventually just
* log it thus ignoring the whole event.
*/
if (request.getHeader(MaxForwardsHeader.NAME) == null) {
// it appears that some buggy providers do send requests
// with no Max-Forwards headers, as we are at application level
// and we know there will be no endless loops
// there is no problem of adding headers and process normally
// this messages
MaxForwardsHeader maxForwards =
SipFactory.getInstance().createHeaderFactory().createMaxForwardsHeader(70);
request.setHeader(maxForwards);
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
try {
// using asterisk voice mail initial notify for messages
// is ok, but on the fly received messages their notify comes
// without subscription-state, so we add it in order to be able to
// process message.
if (request.getMethod().equals(Request.NOTIFY)
&& request.getHeader(EventHeader.NAME) != null
&& ((EventHeader) request.getHeader(EventHeader.NAME))
.getEventType()
.equals(OperationSetMessageWaitingSipImpl.EVENT_PACKAGE)
&& request.getHeader(SubscriptionStateHeader.NAME) == null) {
request.addHeader(
new HeaderFactoryImpl().createSubscriptionStateHeader(SubscriptionStateHeader.ACTIVE));
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
try {
// receiving notify message without subscription state
// used for keep-alive pings, they have done their job
// and are no more need. Skip processing them to avoid
// filling logs with unneeded exceptions.
if (request.getMethod().equals(Request.NOTIFY)
&& request.getHeader(SubscriptionStateHeader.NAME) == null) {
return true;
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
return false;
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processIOException(IOExceptionEvent event) {
try {
if (logger.isTraceEnabled()) logger.trace(event);
// impossible to dispatch, log here
if (logger.isDebugEnabled()) logger.debug("@todo implement processIOException()");
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* The AIM server doesn't like it if we change states too often and we use this method to slow
* things down.
*/
private void pauseBetweenStateChanges() {
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
logger.debug("Pausing between state changes was interrupted", ex);
}
}
/** Updates Jitsi icon notification to reflect current global status. */
public void updateJitsiIconNotification() {
String status;
if (getGlobalStatus().isOnline()) {
// At least one provider is online
status = JitsiApplication.getResString(R.string.service_gui_ONLINE);
} else {
// There are no active providers so we consider to be in
// the offline state
status = JitsiApplication.getResString(R.string.service_gui_OFFLINE);
}
int notificationID = OSGiService.getGeneralNotificationId();
if (notificationID == -1) {
logger.debug(
"Not displaying status notification because"
+ " there's no global notification icon available.");
return;
}
AndroidUtils.updateGeneralNotification(
JitsiApplication.getGlobalContext(),
notificationID,
JitsiApplication.getResString(R.string.app_name),
status,
System.currentTimeMillis());
}
/**
* Send an instant message from the tested operation set and assert reception by the tester agent.
*/
public void firstTestReceiveMessage() {
String body = "This is an IM coming from the tester agent" + " on " + new Date().toString();
ImEventCollector evtCollector = new ImEventCollector();
// add a msg listener and register to the op set and send an instant
// msg from the tester agent.
opSetBasicIM1.addMessageListener(evtCollector);
Contact testerAgentContact = opSetPresence2.findContactByID(fixture.userID1);
logger.debug("Will send message " + body + " to: " + testerAgentContact);
opSetBasicIM2.sendInstantMessage(testerAgentContact, opSetBasicIM2.createMessage(body));
evtCollector.waitForEvent(10000);
opSetBasicIM1.removeMessageListener(evtCollector);
// assert reception of a message event
assertTrue(
"No events delivered upon a received message", evtCollector.collectedEvents.size() > 0);
// assert event instance of Message Received Evt
assertTrue(
"Received evt was not an instance of " + MessageReceivedEvent.class.getName(),
evtCollector.collectedEvents.get(0) instanceof MessageReceivedEvent);
// assert source contact == testAgent.uin
MessageReceivedEvent evt = (MessageReceivedEvent) evtCollector.collectedEvents.get(0);
assertEquals("message sender ", evt.getSourceContact().getAddress(), fixture.userID2);
// assert messageBody == body
assertEquals("message body", body, evt.getSourceMessage().getContent());
}
/**
* Sends a typing notification state.
*
* @param typingState the typing notification state to send
* @return the result of this operation. One of the TYPING_NOTIFICATION_XXX constants defined in
* this class
*/
public int sendTypingNotification(int typingState) {
// If this chat transport does not support sms messaging we do
// nothing here.
if (!allowsTypingNotifications()) return -1;
ProtocolProviderService protocolProvider = contact.getProtocolProvider();
OperationSetTypingNotifications tnOperationSet =
protocolProvider.getOperationSet(OperationSetTypingNotifications.class);
// if protocol is not registered or contact is offline don't
// try to send typing notifications
if (protocolProvider.isRegistered()
&& contact.getPresenceStatus().getStatus() >= PresenceStatus.ONLINE_THRESHOLD) {
try {
tnOperationSet.sendTypingNotification(contact, typingState);
return ChatPanel.TYPING_NOTIFICATION_SUCCESSFULLY_SENT;
} catch (Exception ex) {
logger.error("Failed to send typing notifications.", ex);
return ChatPanel.TYPING_NOTIFICATION_SEND_FAILED;
}
}
return ChatPanel.TYPING_NOTIFICATION_SEND_FAILED;
}
/**
* Called to indicate that delivery of a WhiteboardObject sent earlier has failed. Reason code and
* phrase are contained by the <tt>WhiteboardObjectDeliveryFailedEvent</tt>
*
* @param evt the <tt>WhiteboardObjectDeliveryFailedEvent</tt> containing the ID of the
* WhiteboardObject whose delivery has failed.
*/
public void whiteboardObjectDeliveryFailed(WhiteboardObjectDeliveryFailedEvent evt) {
String errorMessage = null;
if (evt.getErrorCode() == WhiteboardObjectDeliveryFailedEvent.NETWORK_FAILURE) {
errorMessage = "Network failure.";
} else if (evt.getErrorCode()
== WhiteboardObjectDeliveryFailedEvent.OFFLINE_MESSAGES_NOT_SUPPORTED) {
errorMessage = "Offline messages aren't supported.";
} else if (evt.getErrorCode() == WhiteboardObjectDeliveryFailedEvent.PROVIDER_NOT_REGISTERED) {
errorMessage = "Protocol provider is not registered.";
} else if (evt.getErrorCode() == WhiteboardObjectDeliveryFailedEvent.INTERNAL_ERROR) {
errorMessage = "An internal error occured.";
} else if (evt.getErrorCode() == WhiteboardObjectDeliveryFailedEvent.UNKNOWN_ERROR) {
errorMessage = "An unknown error occured.";
}
String debugErrorMessage =
"WBObjectDeliveryFailedEvent: The following object: "
+ evt.getSourceWhiteboardObject()
+ " has NOT been delivered to "
+ evt.getDestinationContact().getDisplayName()
+ " because of the following error: "
+ errorMessage;
logger.debug(debugErrorMessage);
WhiteboardActivator.getUiService()
.getPopupDialog()
.showMessagePopupDialog(errorMessage, "Error", PopupDialog.ERROR_MESSAGE);
}
/**
* Called when the underlying implementation has received an indication that a WhiteboardObject,
* sent earlier has been successfully received by the destination.
*
* @param evt the WhiteboardObjectDeliveredEvent containing the id of the WhiteboardObject that
* has caused the event.
*/
public void whiteboardObjectDelivered(WhiteboardObjectDeliveredEvent evt) {
logger.debug(
"WBObjectDeliveredEvent: The following object: "
+ evt.getSourceWhiteboardObject()
+ " has been delivered to "
+ evt.getDestinationContact().getDisplayName());
}
/**
* Returns the cached recent messages history.
*
* @return
* @throws IOException
*/
private History getHistory() throws IOException {
synchronized (historyID) {
HistoryService historyService =
MessageHistoryActivator.getMessageHistoryService().getHistoryService();
if (history == null) {
history = historyService.createHistory(historyID, recordStructure);
// lets check the version if not our version, re-create
// history (delete it)
HistoryReader reader = history.getReader();
boolean delete = false;
QueryResultSet<HistoryRecord> res = reader.findLast(1);
if (res != null && res.hasNext()) {
HistoryRecord hr = res.next();
if (hr.getPropertyValues().length >= 4) {
if (!hr.getPropertyValues()[3].equals(RECENT_MSGS_VER)) delete = true;
} else delete = true;
}
if (delete) {
// delete it
try {
historyService.purgeLocallyStoredHistory(historyID);
history = historyService.createHistory(historyID, recordStructure);
} catch (IOException ex) {
logger.error("Cannot delete recent_messages history", ex);
}
}
}
return history;
}
}
/**
* We fill the protocolProviderTable with all running protocol providers at the start of the
* bundle.
*/
private void init() {
SystrayActivator.bundleContext.addServiceListener(new ProtocolProviderServiceListener());
ServiceReference[] protocolProviderRefs = null;
try {
protocolProviderRefs =
SystrayActivator.bundleContext.getServiceReferences(
ProtocolProviderService.class.getName(), null);
} catch (InvalidSyntaxException ex) {
// this shouldn't happen since we're providing no parameter string
// but let's log just in case.
logger.error("Error while retrieving service refs", ex);
return;
}
// in case we found any
if (protocolProviderRefs != null) {
for (int i = 0; i < protocolProviderRefs.length; i++) {
ProtocolProviderService provider =
(ProtocolProviderService)
SystrayActivator.bundleContext.getService(protocolProviderRefs[i]);
boolean isHidden =
provider.getAccountID().getAccountProperties().get("HIDDEN_PROTOCOL") != null;
if (!isHidden) this.addAccount(provider);
}
}
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processTimeout(TimeoutEvent event) {
try {
Transaction transaction;
if (event.isServerTransaction()) {
transaction = event.getServerTransaction();
} else {
transaction = event.getClientTransaction();
}
ProtocolProviderServiceSipImpl recipient = getServiceData(transaction);
if (recipient == null) {
logger.error(
"We received a timeout which wasn't "
+ "marked, please report this to "
+ "*****@*****.**");
} else {
recipient.processTimeout(event);
}
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* A method that would simply send messages to a group of people so that they would get notified
* that tests are being run.
*/
public void testSendFunMessages() {
String hostname = "";
try {
hostname = java.net.InetAddress.getLocalHost().getHostName() + ": ";
} catch (UnknownHostException ex) {
}
String message =
hostname
+ "Hello this is the SIP Communicator (version "
+ System.getProperty("sip-communicator.version")
+ ") build on: "
+ new Date().toString()
+ ". Have a very nice day!";
String list = System.getProperty("accounts.reporting.ICQ_REPORT_LIST");
logger.debug("Will send message " + message + " to: " + list);
// if no property is specified - return
if (list == null || list.trim().length() == 0) return;
StringTokenizer tokenizer = new StringTokenizer(list, " ");
while (tokenizer.hasMoreTokens()) {
fixture.testerAgent.sendMessage(tokenizer.nextToken(), message);
}
}
/**
* Put the stack in a state where it can receive data on three UDP/TCP ports (2 for clear
* communication, 1 for TLS). That is to say create the related JAIN-SIP <tt>ListeningPoint</tt>s
* and <tt>SipProvider</tt>s.
*
* @throws OperationFailedException if creating one of the underlying <tt>SipProvider</tt>s fails
* for whatever reason.
*/
private void startListening() throws OperationFailedException {
try {
int bindRetriesValue = getBindRetriesValue();
this.createProvider(this.getPreferredClearPort(), bindRetriesValue, false);
this.createProvider(this.getPreferredSecurePort(), bindRetriesValue, true);
this.stack.start();
if (logger.isTraceEnabled()) logger.trace("started listening");
} catch (Exception ex) {
logger.error(
"An unexpected error happened while creating the" + "SipProviders and ListeningPoints.");
throw new OperationFailedException(
"An unexpected error hapenned" + "while initializing the SIP stack",
OperationFailedException.INTERNAL_ERROR,
ex);
}
}
/**
* Sets the icon for the given file.
*
* @param file the file to set an icon for
* @return the byte array containing the thumbnail
*/
private byte[] getFileThumbnail(File file) {
byte[] bytes = null;
if (FileUtils.isImage(file.getName())) {
try {
ImageIcon image = new ImageIcon(file.toURI().toURL());
int width = image.getIconWidth();
int height = image.getIconHeight();
if (width > THUMBNAIL_WIDTH) width = THUMBNAIL_WIDTH;
if (height > THUMBNAIL_HEIGHT) height = THUMBNAIL_HEIGHT;
bytes = ImageUtils.getScaledInstanceInBytes(image.getImage(), width, height);
} catch (MalformedURLException e) {
if (logger.isDebugEnabled()) logger.debug("Could not locate image.", e);
}
}
return bytes;
}
public void waitForUnsubscribre(long waitFor) {
synchronized (this) {
try {
wait(waitFor);
} catch (InterruptedException ex) {
logger.debug("Interrupted while waiting for a subscription evt", ex);
}
}
}
/**
* Sends a file transfer request to the given <tt>toContact</tt> by specifying the local and
* remote file path and the <tt>fromContact</tt>, sending the file.
*
* @param toContact the contact that should receive the file
* @param file the file to send
* @return the transfer object
* @throws IllegalStateException if the protocol provider is not registered or connected
* @throws IllegalArgumentException if some of the arguments doesn't fit the protocol requirements
*/
public FileTransfer sendFile(Contact toContact, File file)
throws IllegalStateException, IllegalArgumentException {
assertConnected();
if (file.length() > getMaximumFileLength())
throw new IllegalArgumentException("File length exceeds the allowed one for this protocol");
// Get the aim connection
AimConnection aimConnection = icqProvider.getAimConnection();
// Create an outgoing file transfer instance
OutgoingFileTransfer outgoingFileTransfer =
aimConnection
.getIcbmService()
.getRvConnectionManager()
.createOutgoingFileTransfer(new Screenname(toContact.getAddress()));
String id =
String.valueOf(outgoingFileTransfer.getRvSessionInfo().getRvSession().getRvSessionId());
FileTransferImpl outFileTransfer =
new FileTransferImpl(outgoingFileTransfer, id, toContact, file, FileTransfer.OUT);
// Adding the file to the outgoing file transfer
try {
outgoingFileTransfer.setSingleFile(new File(file.getPath()));
} catch (IOException e) {
if (logger.isDebugEnabled()) logger.debug("Error sending file", e);
return null;
}
// Notify all interested listeners that a file transfer has been
// created.
FileTransferCreatedEvent event = new FileTransferCreatedEvent(outFileTransfer, new Date());
fireFileTransferCreated(event);
// Sending the file
outgoingFileTransfer.sendRequest(new InvitationMessage(""));
outFileTransfer.fireStatusChangeEvent(FileTransferStatusChangeEvent.PREPARING);
return outFileTransfer;
}
/**
* Function called when a icq file transfer request arrive
*
* @param manager the joustsim manager
* @param transfer the incoming transfer
*/
public void handleNewIncomingConnection(
RvConnectionManager manager, IncomingRvConnection transfer) {
if (transfer instanceof IncomingFileTransfer) {
if (logger.isTraceEnabled())
logger.trace("Incoming Icq file transfer request " + transfer.getClass());
if (!(transfer instanceof IncomingFileTransfer)) {
logger.warn("Wrong file transfer.");
return;
}
OperationSetPersistentPresenceIcqImpl opSetPersPresence =
(OperationSetPersistentPresenceIcqImpl)
icqProvider.getOperationSet(OperationSetPersistentPresence.class);
Contact sender =
opSetPersPresence.findContactByID(transfer.getBuddyScreenname().getFormatted());
IncomingFileTransfer incomingFileTransfer = (IncomingFileTransfer) transfer;
final Date newDate = new Date();
final IncomingFileTransferRequest req =
new IncomingFileTransferRequestIcqImpl(
icqProvider, this, incomingFileTransfer, sender, newDate);
// this handels when we receive request and before accept or decline
// it we receive cancel
transfer.addEventListener(
new RvConnectionEventListener() {
public void handleEventWithStateChange(
RvConnection transfer, RvConnectionState state, RvConnectionEvent event) {
if (state == FileTransferState.FAILED && event instanceof BuddyCancelledEvent) {
fireFileTransferRequestCanceled(
new FileTransferRequestEvent(
OperationSetFileTransferIcqImpl.this, req, newDate));
}
}
public void handleEvent(RvConnection arg0, RvConnectionEvent arg1) {}
});
fireFileTransferRequest(new FileTransferRequestEvent(this, req, newDate));
}
}
/**
* Sends the <tt>message</tt> to the destination indicated by the <tt>to</tt> contact.
*
* @param to the <tt>Contact</tt> to send <tt>message</tt> to
* @param message the <tt>Message</tt> to send.
* @throws java.lang.IllegalStateException if the underlying stack is not registered and
* initialized.
* @throws java.lang.IllegalArgumentException if <tt>to</tt> is not an instance of ContactImpl.
*/
public void sendInstantMessage(Contact to, Message message)
throws IllegalStateException, IllegalArgumentException {
if (!(to instanceof ContactSipImpl))
throw new IllegalArgumentException("The specified contact is not a Sip contact." + to);
assertConnected();
// offline message
if (to.getPresenceStatus().equals(sipStatusEnum.getStatus(SipStatusEnum.OFFLINE))
&& !offlineMessageSupported) {
if (logger.isDebugEnabled()) logger.debug("trying to send a message to an offline contact");
fireMessageDeliveryFailed(
message, to, MessageDeliveryFailedEvent.OFFLINE_MESSAGES_NOT_SUPPORTED);
return;
}
// create the message
Request mes;
try {
mes = createMessageRequest(to, message);
} catch (OperationFailedException ex) {
logger.error("Failed to create the message.", ex);
fireMessageDeliveryFailed(message, to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return;
}
try {
sendMessageRequest(mes, to, message);
} catch (TransactionUnavailableException ex) {
logger.error(
"Failed to create messageTransaction.\n"
+ "This is most probably a network connection error.",
ex);
fireMessageDeliveryFailed(message, to, MessageDeliveryFailedEvent.NETWORK_FAILURE);
return;
} catch (SipException ex) {
logger.error("Failed to send the message.", ex);
fireMessageDeliveryFailed(message, to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return;
}
}
public AuthorizationRequest createAuthorizationRequest(Contact contact) {
logger.trace("createAuthorizationRequest " + contact);
AuthorizationRequest authReq = new AuthorizationRequest();
authReq.setReason(authorizationRequestReason);
isAuthorizationRequestSent = true;
return authReq;
}
public void waitForAuthRequest(long waitFor) {
synchronized (this) {
if (isAuthorizationRequestReceived) return;
try {
wait(waitFor);
} catch (InterruptedException ex) {
logger.debug("Interrupted while waiting for a subscription evt", ex);
}
}
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processResponse(ResponseEvent event) {
try {
// we don't have to accept the transaction since we
// created the request
ClientTransaction transaction = event.getClientTransaction();
if (logger.isTraceEnabled())
logger.trace(
"received response: "
+ event.getResponse().getStatusCode()
+ " "
+ event.getResponse().getReasonPhrase());
if (transaction == null) {
logger.warn("Transaction is null, probably already expired!");
return;
}
ProtocolProviderServiceSipImpl service = getServiceData(transaction);
if (service != null) {
// Mark the dialog for the dispatching of later in-dialog
// responses. If there is no dialog then the initial request
// sure is marked otherwise we won't have found the service with
// getServiceData(). The request has to be marked in case we
// receive one more response in an out-of-dialog transaction.
if (event.getDialog() != null) {
SipApplicationData.setApplicationData(
event.getDialog(), SipApplicationData.KEY_SERVICE, service);
}
service.processResponse(event);
} else {
logger.error(
"We received a response which "
+ "wasn't marked, please report this to "
+ "*****@*****.**");
}
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* Checks whether the carbon is supported by the server or not.
*
* @return <tt>true</tt> if carbon is supported by the server and <tt>false</tt> if not.
*/
private boolean isCarbonSupported() {
try {
return jabberProvider
.getDiscoveryManager()
.discoverInfo(jabberProvider.getAccountID().getService())
.containsFeature(CarbonPacketExtension.NAMESPACE);
} catch (XMPPException e) {
logger.warn("Failed to retrieve carbon support." + e.getMessage());
}
return false;
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processDialogTerminated(DialogTerminatedEvent event) {
try {
ProtocolProviderServiceSipImpl recipient =
(ProtocolProviderServiceSipImpl)
SipApplicationData.getApplicationData(
event.getDialog(), SipApplicationData.KEY_SERVICE);
if (recipient == null) {
logger.error(
"Dialog wasn't marked, please report this to " + "*****@*****.**");
} else {
if (logger.isTraceEnabled()) logger.trace("service was found with dialog data");
recipient.processDialogTerminated(event);
}
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* Notify all listeners of the corresponding account detail change event.
*
* @param source the protocol provider service source
* @param eventID the int ID of the event to dispatch
* @param oldValue the value that the changed property had before the change occurred.
* @param newValue the value that the changed property currently has (after the change has
* occurred).
*/
public void fireServerStoredDetailsChangeEvent(
ProtocolProviderService source, int eventID, Object oldValue, Object newValue) {
ServerStoredDetailsChangeEvent evt =
new ServerStoredDetailsChangeEvent(source, eventID, oldValue, newValue);
Collection<ServerStoredDetailsChangeListener> listeners;
synchronized (serverStoredDetailsListeners) {
listeners = new ArrayList<ServerStoredDetailsChangeListener>(serverStoredDetailsListeners);
}
if (logger.isDebugEnabled())
logger.debug(
"Dispatching a Contact Property Change Event to"
+ listeners.size()
+ " listeners. Evt="
+ evt);
for (ServerStoredDetailsChangeListener listener : listeners)
listener.serverStoredDetailsChanged(evt);
}
/**
* When a sent message is delivered shows it in the chat conversation panel.
*
* @param evt the event containing details on the message delivery
*/
public void messageDelivered(MessageDeliveredEvent evt) {
Contact contact = evt.getDestinationContact();
MetaContact metaContact =
GuiActivator.getContactListService().findMetaContactByContact(contact);
if (logger.isTraceEnabled())
logger.trace("MESSAGE DELIVERED to contact: " + contact.getAddress());
ChatPanel chatPanel = chatWindowManager.getContactChat(metaContact, false);
if (chatPanel != null) {
Message msg = evt.getSourceMessage();
ProtocolProviderService protocolProvider = contact.getProtocolProvider();
if (logger.isTraceEnabled())
logger.trace(
"MESSAGE DELIVERED: process message to chat for contact: "
+ contact.getAddress()
+ " MESSAGE: "
+ msg.getContent());
chatPanel.addMessage(
this.mainFrame.getAccountAddress(protocolProvider),
this.mainFrame.getAccountDisplayName(protocolProvider),
evt.getTimestamp(),
Chat.OUTGOING_MESSAGE,
msg.getContent(),
msg.getContentType(),
msg.getMessageUID(),
evt.getCorrectedMessageUID());
if (evt.isSmsMessage() && !ConfigurationUtils.isSmsNotifyTextDisabled()) {
chatPanel.addMessage(
contact.getDisplayName(),
new Date(),
Chat.ACTION_MESSAGE,
GuiActivator.getResources().getI18NString("service.gui.SMS_SUCCESSFULLY_SENT"),
"text");
}
}
}
