/** Prepares the factory for bundle shutdown. */
public void stop() {
if (logger.isTraceEnabled()) logger.trace("Preparing to stop all protocol providers of" + this);
synchronized (registeredAccounts) {
for (Enumeration<ServiceRegistration> registrations = registeredAccounts.elements();
registrations.hasMoreElements(); ) {
ServiceRegistration reg = registrations.nextElement();
stop(reg);
reg.unregister();
}
registeredAccounts.clear();
}
}
/**
* Returns the ServiceReference for the protocol provider corresponding to the specified accountID
* or null if the accountID is unknown.
*
* @param accountID the accountID of the protocol provider we'd like to get
* @return a ServiceReference object to the protocol provider with the specified account id and
* null if the account id is unknown to the provider factory.
*/
public ServiceReference getProviderForAccount(AccountID accountID) {
ServiceRegistration registration;
synchronized (registeredAccounts) {
registration = registeredAccounts.get(accountID);
}
return (registration == null) ? null : registration.getReference();
}
/**
* 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;
}
/**
* Creates a protocol provider for the given <tt>accountID</tt> and registers it in the bundle
* context. This method has a persistent effect. Once created the resulting account will remain
* installed until removed through the uninstallAccount method.
*
* @param accountID the account identifier
* @return <tt>true</tt> if the account with the given <tt>accountID</tt> is successfully loaded,
* otherwise returns <tt>false</tt>
*/
public boolean loadAccount(AccountID accountID) {
// Need to obtain the original user id property, instead of calling
// accountID.getUserID(), because this method could return a modified
// version of the user id property.
String userID = accountID.getAccountPropertyString(ProtocolProviderFactory.USER_ID);
ProtocolProviderService service = createService(userID, accountID);
Dictionary<String, String> properties = new Hashtable<String, String>();
properties.put(PROTOCOL, protocolName);
properties.put(USER_ID, userID);
ServiceRegistration serviceRegistration =
bundleContext.registerService(ProtocolProviderService.class.getName(), service, properties);
if (serviceRegistration == null) return false;
else {
synchronized (registeredAccounts) {
registeredAccounts.put(accountID, serviceRegistration);
}
return true;
}
}
/**
* 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;
}
/**
* Returns a copy of the list containing the <tt>AccountID</tt>s of all accounts currently
* registered in this protocol provider.
*
* @return a copy of the list containing the <tt>AccountID</tt>s of all accounts currently
* registered in this protocol provider.
*/
public ArrayList<AccountID> getRegisteredAccounts() {
synchronized (registeredAccounts) {
return new ArrayList<AccountID>(registeredAccounts.keySet());
}
}