/**
* {@inheritDoc}
*
* <p>Implements {@link RegistrationStateChangeListener}. Notifies this instance that there has
* been a change in the <tt>RegistrationState</tt> of {@link #protocolProvider}. Subscribes this
* instance to {@link ColibriConferenceIQ}s as soon as <tt>protocolProvider</tt> is registered and
* unsubscribes it as soon as <tt>protocolProvider</tt> is unregistered.
*/
public void registrationStateChanged(RegistrationStateChangeEvent ev) {
RegistrationState registrationState = ev.getNewState();
if (RegistrationState.REGISTERED.equals(registrationState)) {
protocolProvider.getConnection().addPacketListener(this, this);
} else if (RegistrationState.UNREGISTERED.equals(registrationState)) {
XMPPConnection connection = protocolProvider.getConnection();
if (connection != null) connection.removePacketListener(this);
}
}
/**
* Subscribes this provider as interested in receiving notifications for new mail messages from
* Google mail services such as Gmail or Google Apps.
*/
private void subscribeForGmailNotifications() {
// first check support for the notification service
String accountIDService = jabberProvider.getAccountID().getService();
boolean notificationsAreSupported =
jabberProvider.isFeatureSupported(accountIDService, NewMailNotificationIQ.NAMESPACE);
if (!notificationsAreSupported) {
if (logger.isDebugEnabled())
logger.debug(
accountIDService
+ " does not seem to provide a Gmail notification "
+ " service so we won't be trying to subscribe for it");
return;
}
if (logger.isDebugEnabled())
logger.debug(
accountIDService
+ " seems to provide a Gmail notification "
+ " service so we will try to subscribe for it");
ProviderManager providerManager = ProviderManager.getInstance();
providerManager.addIQProvider(
MailboxIQ.ELEMENT_NAME, MailboxIQ.NAMESPACE, new MailboxIQProvider());
providerManager.addIQProvider(
NewMailNotificationIQ.ELEMENT_NAME,
NewMailNotificationIQ.NAMESPACE,
new NewMailNotificationProvider());
Connection connection = jabberProvider.getConnection();
connection.addPacketListener(new MailboxIQListener(), new PacketTypeFilter(MailboxIQ.class));
connection.addPacketListener(
new NewMailNotificationListener(), new PacketTypeFilter(NewMailNotificationIQ.class));
if (opSetPersPresence.getCurrentStatusMessage().equals(JabberStatusEnum.OFFLINE)) return;
// create a query with -1 values for newer-than-tid and
// newer-than-time attributes
MailboxQueryIQ mailboxQuery = new MailboxQueryIQ();
if (logger.isTraceEnabled())
logger.trace(
"sending mailNotification for acc: "
+ jabberProvider.getAccountID().getAccountUniqueID());
jabberProvider.getConnection().sendPacket(mailboxQuery);
}
/**
* Sends enable or disable carbon packet to the server.
*
* @param enable if <tt>true</tt> sends enable packet otherwise sends disable packet.
*/
private void enableDisableCarbon(final boolean enable) {
IQ iq =
new IQ() {
@Override
public String getChildElementXML() {
return "<" + (enable ? "enable" : "disable") + " xmlns='urn:xmpp:carbons:2' />";
}
};
Packet response = null;
try {
PacketCollector packetCollector =
jabberProvider
.getConnection()
.createPacketCollector(new PacketIDFilter(iq.getPacketID()));
iq.setFrom(jabberProvider.getOurJID());
iq.setType(IQ.Type.SET);
jabberProvider.getConnection().sendPacket(iq);
response = packetCollector.nextResult(SmackConfiguration.getPacketReplyTimeout());
packetCollector.cancel();
} catch (Exception e) {
logger.error("Failed to enable carbon.", e);
}
isCarbonEnabled = false;
if (response == null) {
logger.error("Failed to enable carbon. No response is received.");
} else if (response.getError() != null) {
logger.error("Failed to enable carbon: " + response.getError());
} else if (!(response instanceof IQ) || !((IQ) response).getType().equals(IQ.Type.RESULT)) {
logger.error("Failed to enable carbon. The response is not correct.");
} else {
isCarbonEnabled = true;
}
}
/**
* Implements {@link PacketListener}. Notifies this instance that a specific {@link Packet} (which
* this instance has already expressed interest into by returning <tt>true</tt> from {@link
* #accept(Packet)}) has been received.
*
* @param packet the <tt>Packet</tt> which has been received and which this instance is given a
* chance to process
*/
public void processPacket(Packet packet) {
/*
* As we do elsewhere, acknowledge the receipt of the Packet first and
* then go about our business with it.
*/
IQ iq = (IQ) packet;
if (iq.getType() == IQ.Type.SET)
protocolProvider.getConnection().sendPacket(IQ.createResultIQ(iq));
/*
* Now that the acknowledging is out of the way, do go about our
* business with the Packet.
*/
ColibriConferenceIQ conferenceIQ = (ColibriConferenceIQ) iq;
boolean interrupted = false;
try {
processColibriConferenceIQ(conferenceIQ);
} catch (Throwable t) {
logger.error(
"An error occurred during the processing of a " + packet.getClass().getName() + " packet",
t);
if (t instanceof InterruptedException) {
/*
* We cleared the interrupted state of the current Thread by
* catching the InterruptedException. However, we do not really
* care whether the current Thread has been interrupted - we
* caught the InterruptedException because we want to swallow
* any Throwable. Consequently, we should better restore the
* interrupted state.
*/
interrupted = true;
} else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
if (interrupted) Thread.currentThread().interrupt();
}
/**
* Sends a file transfer request to the given <tt>toContact</tt>.
*
* @return the transfer object
* @param toContact the contact that should receive the file
* @param file file to send
* @param gw special gateway to be used for receiver if its jid misses the domain part
*/
FileTransfer sendFile(Contact toContact, File file, String gw)
throws IllegalStateException, IllegalArgumentException, OperationNotSupportedException {
OutgoingFileTransferJabberImpl outgoingTransfer = null;
try {
assertConnected();
if (file.length() > getMaximumFileLength())
throw new IllegalArgumentException("File length exceeds the allowed one for this protocol");
String fullJid = null;
// Find the jid of the contact which support file transfer
// and is with highest priority if more than one found
// if we have equals priorities
// choose the one that is more available
OperationSetMultiUserChat mucOpSet =
jabberProvider.getOperationSet(OperationSetMultiUserChat.class);
if (mucOpSet != null && mucOpSet.isPrivateMessagingContact(toContact.getAddress())) {
fullJid = toContact.getAddress();
} else {
Iterator<Presence> iter =
jabberProvider.getConnection().getRoster().getPresences(toContact.getAddress());
int bestPriority = -1;
PresenceStatus jabberStatus = null;
while (iter.hasNext()) {
Presence presence = iter.next();
if (jabberProvider.isFeatureListSupported(
presence.getFrom(),
new String[] {
"http://jabber.org/protocol/si",
"http://jabber.org/protocol/si/profile/file-transfer"
})) {
int priority =
(presence.getPriority() == Integer.MIN_VALUE) ? 0 : presence.getPriority();
if (priority > bestPriority) {
bestPriority = priority;
fullJid = presence.getFrom();
jabberStatus =
OperationSetPersistentPresenceJabberImpl.jabberStatusToPresenceStatus(
presence, jabberProvider);
} else if (priority == bestPriority && jabberStatus != null) {
PresenceStatus tempStatus =
OperationSetPersistentPresenceJabberImpl.jabberStatusToPresenceStatus(
presence, jabberProvider);
if (tempStatus.compareTo(jabberStatus) > 0) {
fullJid = presence.getFrom();
jabberStatus = tempStatus;
}
}
}
}
}
// First we check if file transfer is at all supported for this
// contact.
if (fullJid == null) {
throw new OperationNotSupportedException(
"Contact client or server does not support file transfers.");
}
if (gw != null && !fullJid.contains("@") && !fullJid.endsWith(gw)) {
fullJid = fullJid + "@" + gw;
}
OutgoingFileTransfer transfer = manager.createOutgoingFileTransfer(fullJid);
outgoingTransfer =
new OutgoingFileTransferJabberImpl(toContact, file, transfer, jabberProvider);
// Notify all interested listeners that a file transfer has been
// created.
FileTransferCreatedEvent event = new FileTransferCreatedEvent(outgoingTransfer, new Date());
fireFileTransferCreated(event);
// Send the file through the Jabber file transfer.
transfer.sendFile(file, "Sending file");
// Start the status and progress thread.
new FileTransferProgressThread(transfer, outgoingTransfer).start();
} catch (XMPPException e) {
logger.error("Failed to send file.", e);
}
return outgoingTransfer;
}
/**
* Helper function used to send a message to a contact, with the given extensions attached.
*
* @param to The contact to send the message to.
* @param toResource The resource to send the message to or null if no resource has been specified
* @param message The message to send.
* @param extensions The XMPP extensions that should be attached to the message before sending.
* @return The MessageDeliveryEvent that resulted after attempting to send this message, so the
* calling function can modify it if needed.
*/
private MessageDeliveredEvent sendMessage(
Contact to, ContactResource toResource, Message message, PacketExtension[] extensions) {
if (!(to instanceof ContactJabberImpl))
throw new IllegalArgumentException("The specified contact is not a Jabber contact." + to);
assertConnected();
org.jivesoftware.smack.packet.Message msg = new org.jivesoftware.smack.packet.Message();
String toJID = null;
if (toResource != null) {
if (toResource.equals(ContactResource.BASE_RESOURCE)) {
toJID = to.getAddress();
} else toJID = ((ContactResourceJabberImpl) toResource).getFullJid();
}
if (toJID == null) {
toJID = to.getAddress();
}
msg.setPacketID(message.getMessageUID());
msg.setTo(toJID);
for (PacketExtension ext : extensions) {
msg.addExtension(ext);
}
if (logger.isTraceEnabled())
logger.trace("Will send a message to:" + toJID + " chat.jid=" + toJID);
MessageDeliveredEvent msgDeliveryPendingEvt =
new MessageDeliveredEvent(message, to, toResource);
MessageDeliveredEvent[] transformedEvents =
messageDeliveryPendingTransform(msgDeliveryPendingEvt);
if (transformedEvents == null || transformedEvents.length == 0) return null;
for (MessageDeliveredEvent event : transformedEvents) {
String content = event.getSourceMessage().getContent();
if (message.getContentType().equals(HTML_MIME_TYPE)) {
msg.setBody(Html2Text.extractText(content));
// Check if the other user supports XHTML messages
// make sure we use our discovery manager as it caches calls
if (jabberProvider.isFeatureListSupported(toJID, HTML_NAMESPACE)) {
// Add the XHTML text to the message
XHTMLManager.addBody(msg, OPEN_BODY_TAG + content + CLOSE_BODY_TAG);
}
} else {
// this is plain text so keep it as it is.
msg.setBody(content);
}
// msg.addExtension(new Version());
if (event.isMessageEncrypted() && isCarbonEnabled) {
msg.addExtension(new CarbonPacketExtension.PrivateExtension());
}
MessageEventManager.addNotificationsRequests(msg, true, false, false, true);
String threadID = getThreadIDForAddress(toJID);
if (threadID == null) threadID = nextThreadID();
msg.setThread(threadID);
msg.setType(org.jivesoftware.smack.packet.Message.Type.chat);
msg.setFrom(jabberProvider.getConnection().getUser());
jabberProvider.getConnection().sendPacket(msg);
putJidForAddress(toJID, threadID);
}
return new MessageDeliveredEvent(message, to, toResource);
}