public void run() {
if (telephony == null) return;
Call createdCall = null;
if (contacts != null) {
Contact contact = (Contact) contacts.get(0);
// NOTE: The multi user call is not yet implemented!
// We just get the first contact and create a call for him.
try {
createdCall = telephony.createCall(contact);
} catch (OperationFailedException e) {
logger.error("The call could not be created: " + e);
callPanel.getParticipantPanel(contact.getDisplayName()).setState(e.getMessage());
removeCallPanelWait(callPanel);
}
// If the call is successfully created we set the created
// Call instance to the already existing CallPanel and we
// add this call to the active calls.
if (createdCall != null) {
callPanel.setCall(createdCall, GuiCallParticipantRecord.OUTGOING_CALL);
activeCalls.put(createdCall, callPanel);
}
} else {
try {
createdCall = telephony.createCall(stringContact);
} catch (ParseException e) {
logger.error("The call could not be created: " + e);
callPanel.getParticipantPanel(stringContact).setState(e.getMessage());
removeCallPanelWait(callPanel);
} catch (OperationFailedException e) {
logger.error("The call could not be created: " + e);
callPanel.getParticipantPanel(stringContact).setState(e.getMessage());
removeCallPanelWait(callPanel);
}
// If the call is successfully created we set the created
// Call instance to the already existing CallPanel and we
// add this call to the active calls.
if (createdCall != null) {
callPanel.setCall(createdCall, GuiCallParticipantRecord.OUTGOING_CALL);
activeCalls.put(createdCall, callPanel);
}
}
}
/**
* Shows a warning message to the user when message delivery has failed.
*
* @param evt the event containing details on the message delivery failure
*/
public void messageDeliveryFailed(MessageDeliveryFailedEvent evt) {
logger.error(evt.getReason());
String errorMsg = null;
Message sourceMessage = (Message) evt.getSource();
Contact sourceContact = evt.getDestinationContact();
MetaContact metaContact =
GuiActivator.getContactListService().findMetaContactByContact(sourceContact);
if (evt.getErrorCode() == MessageDeliveryFailedEvent.OFFLINE_MESSAGES_NOT_SUPPORTED) {
errorMsg =
GuiActivator.getResources()
.getI18NString(
"service.gui.MSG_DELIVERY_NOT_SUPPORTED",
new String[] {sourceContact.getDisplayName()});
} else if (evt.getErrorCode() == MessageDeliveryFailedEvent.NETWORK_FAILURE) {
errorMsg = GuiActivator.getResources().getI18NString("service.gui.MSG_NOT_DELIVERED");
} else if (evt.getErrorCode() == MessageDeliveryFailedEvent.PROVIDER_NOT_REGISTERED) {
errorMsg =
GuiActivator.getResources().getI18NString("service.gui.MSG_SEND_CONNECTION_PROBLEM");
} else if (evt.getErrorCode() == MessageDeliveryFailedEvent.INTERNAL_ERROR) {
errorMsg =
GuiActivator.getResources().getI18NString("service.gui.MSG_DELIVERY_INTERNAL_ERROR");
} else {
errorMsg = GuiActivator.getResources().getI18NString("service.gui.MSG_DELIVERY_ERROR");
}
String reason = evt.getReason();
if (reason != null)
errorMsg +=
" "
+ GuiActivator.getResources()
.getI18NString("service.gui.ERROR_WAS", new String[] {reason});
ChatPanel chatPanel = chatWindowManager.getContactChat(metaContact, sourceContact);
chatPanel.addMessage(
sourceContact.getAddress(),
metaContact.getDisplayName(),
new Date(),
Chat.OUTGOING_MESSAGE,
sourceMessage.getContent(),
sourceMessage.getContentType(),
sourceMessage.getMessageUID(),
evt.getCorrectedMessageUID());
chatPanel.addErrorMessage(metaContact.getDisplayName(), errorMsg);
chatWindowManager.openChat(chatPanel, false);
}
public void contactPolicyChanged(Contact contact) {
// OtrMetaContactButton.this.contact can be null.
if (OtrMetaContactButton.this.otrContact != null
&& contact.equals(OtrMetaContactButton.this.otrContact.contact)) {
setPolicy(OtrActivator.scOtrEngine.getContactPolicy(contact));
}
}
public void setCurrentContact(Contact contact, String resourceName) {
if (contact == null) {
this.otrContact = null;
this.setPolicy(null);
this.setStatus(ScSessionStatus.PLAINTEXT);
return;
}
if (resourceName == null) {
OtrContact otrContact = OtrContactManager.getOtrContact(contact, null);
if (this.otrContact == otrContact) return;
this.otrContact = otrContact;
this.setStatus(OtrActivator.scOtrEngine.getSessionStatus(otrContact));
this.setPolicy(OtrActivator.scOtrEngine.getContactPolicy(contact));
return;
}
for (ContactResource resource : contact.getResources()) {
if (resource.getResourceName().equals(resourceName)) {
OtrContact otrContact = OtrContactManager.getOtrContact(contact, resource);
if (this.otrContact == otrContact) return;
this.otrContact = otrContact;
this.setStatus(OtrActivator.scOtrEngine.getSessionStatus(otrContact));
this.setPolicy(OtrActivator.scOtrEngine.getContactPolicy(contact));
return;
}
}
logger.debug("Could not find resource for contact " + contact);
}
/**
* 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");
}
}
}
/**
* Implements ListSelectionListener.valueChanged. Enables or disables call and hangup buttons
* depending on the selection in the contactlist.
*/
public void valueChanged(ListSelectionEvent e) {
Object o = mainFrame.getContactListPanel().getContactList().getSelectedValue();
if ((e.getFirstIndex() != -1 || e.getLastIndex() != -1) && (o instanceof MetaContact)) {
setCallMetaContact(true);
// Switch automatically to the appropriate pps in account selector
// box and enable callButton if telephony is supported.
Contact contact = ((MetaContact) o).getDefaultContact(OperationSetBasicTelephony.class);
if (contact != null) {
callButton.setEnabled(true);
if (contact.getProtocolProvider().isRegistered())
getAccountSelectorBox().setSelected(contact.getProtocolProvider());
} else {
callButton.setEnabled(false);
}
} else if (phoneNumberCombo.isComboFieldEmpty()) {
callButton.setEnabled(false);
}
}
/**
* Initialize (a new) Whiteboard with contact
*
* @param contact Contact used to init whiteboard
*/
public void initWhiteboard(final Contact contact) {
opSetWb =
(OperationSetWhiteboarding)
contact.getProtocolProvider().getOperationSet(OperationSetWhiteboarding.class);
if (opSetWb == null) {
logger.info("Contact does not support whiteboarding");
return;
}
WhiteboardFrame wbf = getWhiteboardFrame(contact);
if (wbf != null) {
wbf.setVisible(true);
return;
}
new Thread() {
public void run() {
try {
WhiteboardSession wbSession =
opSetWb.createWhiteboardSession(contact.getDisplayName(), null);
WhiteboardFrame wbFrame = new WhiteboardFrame(WhiteboardSessionManager.this, wbSession);
wbFrames.add(wbFrame);
wbFrame.setContact(contact);
wbFrame.setVisible(true);
wbSession.join();
wbSession.invite(contact.getAddress());
} catch (OperationFailedException e) {
logger.error("Creating a whiteboard session failed.", e);
} catch (OperationNotSupportedException e) {
logger.error("Do not support create of whiteboard session", e);
}
}
}.start();
}
/**
* Create a new video call and invite the specified CallPeer to it.
*
* @param callee the address of the callee that we should invite to a new call.
* @param mediaDevice the media device to use for the desktop streaming
* @return CallPeer the CallPeer that will represented by the specified uri. All following state
* change events will be delivered through that call peer. The Call that this peer is a member
* of could be retrieved from the CallParticipatn instance with the use of the corresponding
* method.
* @throws OperationFailedException with the corresponding code if we fail to create the video
* call.
*/
public Call createVideoCall(Contact callee, MediaDevice mediaDevice)
throws OperationFailedException {
return this.createOutgoingVideoCall(callee.getAddress(), mediaDevice);
}
private void contactButton_actionPerformed(ActionEvent e) {
this.setVisible(false);
Contact contact = new Contact();
contact.setVisible(true);
}
/**
* Initializes buttons panel.
*
* @param uiContact the <tt>UIContact</tt> for which we initialize the button panel
*/
private void initButtonsPanel(UIContact uiContact) {
this.remove(chatButton);
this.remove(callButton);
this.remove(callVideoButton);
this.remove(desktopSharingButton);
this.remove(addContactButton);
clearCustomActionButtons();
if (!isSelected) return;
UIContactDetail imContact = null;
// For now we support instance messaging only for contacts in our
// contact list until it's implemented for external source contacts.
if (uiContact.getDescriptor() instanceof MetaContact)
imContact = uiContact.getDefaultContactDetail(OperationSetBasicInstantMessaging.class);
int x = (statusIcon == null ? 0 : statusIcon.getIconWidth()) + LEFT_BORDER + H_GAP;
// Re-initialize the x grid.
constraints.gridx = 0;
int gridX = 0;
if (imContact != null) {
x += addButton(chatButton, ++gridX, x, false);
}
UIContactDetail telephonyContact =
uiContact.getDefaultContactDetail(OperationSetBasicTelephony.class);
// Check if contact has additional phone numbers, if yes show the
// call button
ContactPhoneUtil contactPhoneUtil = null;
// check for phone stored in contact info only
// if telephony contact is missing
if (uiContact.getDescriptor() != null
&& uiContact.getDescriptor() instanceof MetaContact
&& telephonyContact == null) {
contactPhoneUtil = ContactPhoneUtil.getPhoneUtil((MetaContact) uiContact.getDescriptor());
MetaContact metaContact = (MetaContact) uiContact.getDescriptor();
Iterator<Contact> contacts = metaContact.getContacts();
while (contacts.hasNext()) // && !hasPhone)
{
Contact contact = contacts.next();
if (!contact.getProtocolProvider().isRegistered()) continue;
contactPhoneUtil.addDetailsResponseListener(
contact, new DetailsListener(treeNode, callButton, uiContact));
}
}
// for SourceContact in history that do not support telephony, we
// show the button but disabled
List<ProtocolProviderService> providers =
AccountUtils.getOpSetRegisteredProviders(OperationSetBasicTelephony.class, null, null);
if ((telephonyContact != null && telephonyContact.getAddress() != null)
|| (contactPhoneUtil != null && contactPhoneUtil.isCallEnabled() && providers.size() > 0)) {
x += addButton(callButton, ++gridX, x, false);
}
UIContactDetail videoContact =
uiContact.getDefaultContactDetail(OperationSetVideoTelephony.class);
if (videoContact != null
|| (contactPhoneUtil != null && contactPhoneUtil.isVideoCallEnabled())) {
x += addButton(callVideoButton, ++gridX, x, false);
}
UIContactDetail desktopContact =
uiContact.getDefaultContactDetail(OperationSetDesktopSharingServer.class);
if (desktopContact != null
|| (contactPhoneUtil != null && contactPhoneUtil.isDesktopSharingEnabled())) {
x += addButton(desktopSharingButton, ++gridX, x, false);
}
// enable add contact button if contact source has indicated
// that this is possible
if (uiContact.getDescriptor() instanceof SourceContact
&& uiContact.getDefaultContactDetail(OperationSetPersistentPresence.class) != null
&& AccountUtils.getOpSetRegisteredProviders(
OperationSetPersistentPresence.class, null, null)
.size()
> 0
&& !ConfigurationUtils.isAddContactDisabled()) {
x += addButton(addContactButton, ++gridX, x, false);
}
// The list of the contact actions
// we will create a button for every action
Collection<SIPCommButton> contactActions = uiContact.getContactCustomActionButtons();
int lastGridX = gridX;
if (contactActions != null && contactActions.size() > 0) {
lastGridX = initContactActionButtons(contactActions, gridX, x);
} else {
addLabels(gridX);
}
if (lastAddedButton != null) setButtonBg(lastAddedButton, lastGridX, true);
this.setBounds(0, 0, treeContactList.getWidth(), getPreferredSize().height);
}
/**
* 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 protocolContact the source contact of the event
* @param contactResource the resource from which the contact is writing
* @param metaContact the metacontact containing <tt>protocolContact</tt>
* @param message the message to deliver
* @param eventType the event type
* @param timestamp the timestamp of the event
* @param correctedMessageUID the identifier of the corrected message
* @param isPrivateMessaging if <tt>true</tt> the message is received from private messaging
* contact.
* @param privateContactRoom the chat room associated with the private messaging contact.
*/
private void messageReceived(
final Contact protocolContact,
final ContactResource contactResource,
final MetaContact metaContact,
final Message message,
final int eventType,
final Date timestamp,
final String correctedMessageUID,
final boolean isPrivateMessaging,
final ChatRoom privateContactRoom) {
if (!SwingUtilities.isEventDispatchThread()) {
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
messageReceived(
protocolContact,
contactResource,
metaContact,
message,
eventType,
timestamp,
correctedMessageUID,
isPrivateMessaging,
privateContactRoom);
}
});
return;
}
// Obtain the corresponding chat panel.
final ChatPanel chatPanel =
chatWindowManager.getContactChat(
metaContact, protocolContact, contactResource, message.getMessageUID());
// Show an envelope on the sender contact in the contact list and
// in the systray.
if (!chatPanel.isChatFocused()) contactList.setActiveContact(metaContact, true);
// Distinguish the message type, depending on the type of event that
// we have received.
String messageType = null;
if (eventType == MessageReceivedEvent.CONVERSATION_MESSAGE_RECEIVED) {
messageType = Chat.INCOMING_MESSAGE;
} else if (eventType == MessageReceivedEvent.SYSTEM_MESSAGE_RECEIVED) {
messageType = Chat.SYSTEM_MESSAGE;
} else if (eventType == MessageReceivedEvent.SMS_MESSAGE_RECEIVED) {
messageType = Chat.SMS_MESSAGE;
}
String contactAddress =
(contactResource != null)
? protocolContact.getAddress() + " (" + contactResource.getResourceName() + ")"
: protocolContact.getAddress();
chatPanel.addMessage(
contactAddress,
protocolContact.getDisplayName(),
timestamp,
messageType,
message.getContent(),
message.getContentType(),
message.getMessageUID(),
correctedMessageUID);
String resourceName = (contactResource != null) ? contactResource.getResourceName() : null;
if (isPrivateMessaging) {
chatWindowManager.openPrivateChatForChatRoomMember(privateContactRoom, protocolContact);
} else {
chatWindowManager.openChat(chatPanel, false);
}
ChatTransport chatTransport =
chatPanel.getChatSession().findChatTransportForDescriptor(protocolContact, resourceName);
chatPanel.setSelectedChatTransport(chatTransport, true);
}
/**
* Implements the ContactListListener.contactSelected method.
*
* @param evt the <tt>ContactListEvent</tt> that notified us
*/
public void contactClicked(ContactListEvent evt) {
// We're interested only in two click events.
if (evt.getClickCount() < 2) return;
UIContact descriptor = evt.getSourceContact();
// We're currently only interested in MetaContacts.
if (descriptor.getDescriptor() instanceof MetaContact) {
MetaContact metaContact = (MetaContact) descriptor.getDescriptor();
// Searching for the right proto contact to use as default for the
// chat conversation.
Contact defaultContact =
metaContact.getDefaultContact(OperationSetBasicInstantMessaging.class);
// do nothing
if (defaultContact == null) {
defaultContact = metaContact.getDefaultContact(OperationSetSmsMessaging.class);
if (defaultContact == null) return;
}
ProtocolProviderService defaultProvider = defaultContact.getProtocolProvider();
OperationSetBasicInstantMessaging defaultIM =
defaultProvider.getOperationSet(OperationSetBasicInstantMessaging.class);
ProtocolProviderService protoContactProvider;
OperationSetBasicInstantMessaging protoContactIM;
boolean isOfflineMessagingSupported =
defaultIM != null && !defaultIM.isOfflineMessagingSupported();
if (defaultContact.getPresenceStatus().getStatus() < 1
&& (!isOfflineMessagingSupported || !defaultProvider.isRegistered())) {
Iterator<Contact> protoContacts = metaContact.getContacts();
while (protoContacts.hasNext()) {
Contact contact = protoContacts.next();
protoContactProvider = contact.getProtocolProvider();
protoContactIM =
protoContactProvider.getOperationSet(OperationSetBasicInstantMessaging.class);
if (protoContactIM != null
&& protoContactIM.isOfflineMessagingSupported()
&& protoContactProvider.isRegistered()) {
defaultContact = contact;
}
}
}
ContactEventHandler contactHandler =
mainFrame.getContactHandler(defaultContact.getProtocolProvider());
contactHandler.contactClicked(defaultContact, evt.getClickCount());
} else if (descriptor.getDescriptor() instanceof SourceContact) {
SourceContact contact = (SourceContact) descriptor.getDescriptor();
List<ContactDetail> imDetails =
contact.getContactDetails(OperationSetBasicInstantMessaging.class);
List<ContactDetail> mucDetails = contact.getContactDetails(OperationSetMultiUserChat.class);
if (imDetails != null && imDetails.size() > 0) {
ProtocolProviderService pps =
imDetails.get(0).getPreferredProtocolProvider(OperationSetBasicInstantMessaging.class);
GuiActivator.getUIService()
.getChatWindowManager()
.startChat(contact.getContactAddress(), pps);
} else if (mucDetails != null && mucDetails.size() > 0) {
ChatRoomWrapper room =
GuiActivator.getMUCService().findChatRoomWrapperFromSourceContact(contact);
if (room == null) {
// lets check by id
ProtocolProviderService pps =
mucDetails.get(0).getPreferredProtocolProvider(OperationSetMultiUserChat.class);
room =
GuiActivator.getMUCService()
.findChatRoomWrapperFromChatRoomID(contact.getContactAddress(), pps);
if (room == null) {
GuiActivator.getMUCService()
.createChatRoom(
contact.getContactAddress(),
pps,
new ArrayList<String>(),
"",
false,
false,
false);
}
}
if (room != null) GuiActivator.getMUCService().openChatRoom(room);
} else {
List<ContactDetail> smsDetails = contact.getContactDetails(OperationSetSmsMessaging.class);
if (smsDetails != null && smsDetails.size() > 0) {
GuiActivator.getUIService()
.getChatWindowManager()
.startChat(contact.getContactAddress(), true);
}
}
}
}