/**
* 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);
}
}
}
/**
* Removes the specified account from the list of accounts that this provider factory is handling.
* If the specified accountID is unknown to the ProtocolProviderFactory, the call has no effect
* and false is returned. This method is persistent in nature and once called the account
* corresponding to the specified ID will not be loaded during future runs of the project.
*
* @param accountID the ID of the account to remove.
* @return true if an account with the specified ID existed and was removed and false otherwise.
*/
public boolean uninstallAccount(AccountID accountID) {
// unregister the protocol provider
ServiceReference serRef = getProviderForAccount(accountID);
if (serRef == null) return false;
ProtocolProviderService protocolProvider =
(ProtocolProviderService) SipActivator.getBundleContext().getService(serRef);
try {
protocolProvider.unregister();
} catch (OperationFailedException e) {
logger.error(
"Failed to unregister protocol provider for account : "
+ accountID
+ " caused by : "
+ e);
}
ServiceRegistration registration = (ServiceRegistration) registeredAccounts.remove(accountID);
if (registration == null) return false;
// kill the service
registration.unregister();
return removeStoredAccount(SipActivator.getBundleContext(), accountID);
}
/** Fired when an account has changed its status. We update the icon in the menu. */
public void providerStatusChanged(ProviderPresenceStatusChangeEvent evt) {
ProtocolProviderService pps = evt.getProvider();
StatusSelector selectorBox = (StatusSelector) accountSelectors.get(pps.getAccountID());
if (selectorBox == null) return;
selectorBox.updateStatus(evt.getNewStatus());
}
/**
* Start this instance by created XMPP account using igven parameters.
*
* @param serverAddress XMPP server address.
* @param xmppDomain XMPP authentication domain.
* @param xmppLoginPassword XMPP login(optional).
* @param nickName authentication login.
* @param listener the listener that will be notified about created protocol provider's
* registration state changes.
*/
public void start(
String serverAddress,
String xmppDomain,
String xmppLoginPassword,
String nickName,
RegistrationStateChangeListener listener) {
this.regListener = listener;
xmppProviderFactory =
ProtocolProviderFactory.getProtocolProviderFactory(
FocusBundleActivator.bundleContext, ProtocolNames.JABBER);
if (xmppLoginPassword != null) {
xmppAccount =
xmppProviderFactory.createAccount(
FocusAccountFactory.createFocusAccountProperties(
serverAddress, xmppDomain, nickName, xmppLoginPassword));
} else {
xmppAccount =
xmppProviderFactory.createAccount(
FocusAccountFactory.createFocusAccountProperties(
serverAddress, xmppDomain, nickName));
}
if (!xmppProviderFactory.loadAccount(xmppAccount)) {
throw new RuntimeException("Failed to load account: " + xmppAccount);
}
ServiceReference protoRef = xmppProviderFactory.getProviderForAccount(xmppAccount);
protocolService =
(ProtocolProviderService) FocusBundleActivator.bundleContext.getService(protoRef);
protocolService.addRegistrationStateChangeListener(this);
}
/**
* Adds the account corresponding to the given protocol provider to this menu.
*
* @param protocolProvider the protocol provider corresponding to the account to add
*/
private void addAccount(ProtocolProviderService protocolProvider) {
OperationSetPresence presence =
(OperationSetPresence) protocolProvider.getOperationSet(OperationSetPresence.class);
if (presence == null) {
StatusSimpleSelector simpleSelector =
new StatusSimpleSelector(parentSystray, protocolProvider);
this.accountSelectors.put(protocolProvider.getAccountID(), simpleSelector);
this.add(simpleSelector);
} else {
StatusSelector statusSelector = new StatusSelector(parentSystray, protocolProvider, presence);
this.accountSelectors.put(protocolProvider.getAccountID(), statusSelector);
this.add(statusSelector);
presence.addProviderPresenceStatusListener(new SystrayProviderPresenceStatusListener());
}
}
/**
* Removes the specified account from the list of accounts that this provider factory is handling.
* If the specified accountID is unknown to the ProtocolProviderFactory, the call has no effect
* and false is returned. This method is persistent in nature and once called the account
* corresponding to the specified ID will not be loaded during future runs of the project.
*
* @param accountID the ID of the account to remove.
* @return true if an account with the specified ID existed and was removed and false otherwise.
*/
public boolean uninstallAccount(AccountID accountID) {
// Unregister the protocol provider.
ServiceReference serRef = getProviderForAccount(accountID);
boolean wasAccountExisting = false;
// If the protocol provider service is registered, first unregister the
// service.
if (serRef != null) {
BundleContext bundleContext = getBundleContext();
ProtocolProviderService protocolProvider =
(ProtocolProviderService) bundleContext.getService(serRef);
try {
protocolProvider.unregister();
} catch (OperationFailedException ex) {
logger.error(
"Failed to unregister protocol provider for account: "
+ accountID
+ " caused by: "
+ ex);
}
}
ServiceRegistration registration;
synchronized (registeredAccounts) {
registration = registeredAccounts.remove(accountID);
}
// first remove the stored account so when PP is unregistered we can
// distinguish between deleted or just disabled account
wasAccountExisting = removeStoredAccount(accountID);
if (registration != null) {
// Kill the service.
registration.unregister();
}
return wasAccountExisting;
}
/**
* Unloads the account corresponding to the given <tt>accountID</tt>. Unregisters the
* corresponding protocol provider, but keeps the account in contrast to the uninstallAccount
* method.
*
* @param accountID the account identifier
* @return true if an account with the specified ID existed and was unloaded and false otherwise.
*/
public boolean unloadAccount(AccountID accountID) {
// Unregister the protocol provider.
ServiceReference serRef = getProviderForAccount(accountID);
if (serRef == null) {
return false;
}
BundleContext bundleContext = getBundleContext();
ProtocolProviderService protocolProvider =
(ProtocolProviderService) bundleContext.getService(serRef);
try {
protocolProvider.unregister();
} catch (OperationFailedException ex) {
logger.error(
"Failed to unregister protocol provider for account : "
+ accountID
+ " caused by: "
+ ex);
}
ServiceRegistration registration;
synchronized (registeredAccounts) {
registration = registeredAccounts.remove(accountID);
}
if (registration == null) {
return false;
}
// Kill the service.
registration.unregister();
return true;
}
/**
* Creates an account for the given user and password.
*
* @param providerFactory the ProtocolProviderFactory which will create the account
* @param user the user identifier
* @return the <tt>ProtocolProviderService</tt> for the new account.
*/
public ProtocolProviderService installAccount(
ProtocolProviderFactory providerFactory, String user) throws OperationFailedException {
Hashtable<String, String> accountProperties = new Hashtable<String, String>();
accountProperties.put(
ProtocolProviderFactory.ACCOUNT_ICON_PATH,
"resources/images/protocol/gibberish/gibberish32x32.png");
if (registration.isRememberPassword()) {
accountProperties.put(ProtocolProviderFactory.PASSWORD, registration.getPassword());
}
if (isModification()) {
providerFactory.uninstallAccount(protocolProvider.getAccountID());
this.protocolProvider = null;
setModification(false);
}
try {
AccountID accountID = providerFactory.installAccount(user, accountProperties);
ServiceReference serRef = providerFactory.getProviderForAccount(accountID);
protocolProvider =
(ProtocolProviderService) GibberishAccRegWizzActivator.bundleContext.getService(serRef);
} catch (IllegalStateException exc) {
logger.warn(exc.getMessage());
throw new OperationFailedException(
"Account already exists.", OperationFailedException.IDENTIFICATION_CONFLICT);
} catch (Exception exc) {
logger.warn(exc.getMessage());
throw new OperationFailedException(
"Failed to add account", OperationFailedException.GENERAL_ERROR);
}
return protocolProvider;
}
/**
* Shuts down the <code>ProtocolProviderService</code> representing an account registered with
* this factory.
*
* @param registeredAccount the <code>ServiceRegistration</code> of the <code>
* ProtocolProviderService</code> representing an account registered with this factory
*/
protected void stop(ServiceRegistration registeredAccount) {
ProtocolProviderService protocolProviderService =
(ProtocolProviderService) getBundleContext().getService(registeredAccount.getReference());
protocolProviderService.shutdown();
}
/**
* Removes the query from protocol provider service presence listeners.
*
* @param pps the protocol provider service.
*/
public void removeQueryFromProviderPresenceListeners(ProtocolProviderService pps) {
OperationSetMultiUserChat opSetMUC = pps.getOperationSet(OperationSetMultiUserChat.class);
if (opSetMUC != null) {
opSetMUC.removePresenceListener(this);
}
}
/**
* Removes the account corresponding to the given protocol provider from this menu.
*
* @param protocolProvider the protocol provider corresponding to the account to remove.
*/
private void removeAccount(ProtocolProviderService protocolProvider) {
Component c = (Component) this.accountSelectors.get(protocolProvider.getAccountID());
this.remove(c);
}
/** Stops this instance and removes temporary XMPP account. */
public void stop() {
protocolService.removeRegistrationStateChangeListener(this);
xmppProviderFactory.uninstallAccount(xmppAccount);
}
/** {@inheritDoc} */
@Override
public String toString() {
return protocolService != null ? protocolService.toString() : super.toString();
}
/** Returns <tt>true</tt> if underlying protocol provider service has registered. */
public boolean isRegistered() {
return protocolService.isRegistered();
}
/** Utility method for obtaining operation sets from underlying protocol provider service. */
public <T extends OperationSet> T getOperationSet(Class<T> opSetClass) {
return protocolService.getOperationSet(opSetClass);
}
/**
* 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);
}
}
}
}
