/**
* Returns the prefix for all persistently stored properties of the account with the specified id.
*
* @param bundleContext a currently valid bundle context.
* @param accountID the AccountID of the account whose properties we're looking for.
* @param sourcePackageName a String containing the package name of the concrete factory class
* that extends us.
* @return a String indicating the ConfigurationService property name prefix under which all
* account properties are stored or null if no account corresponding to the specified id was
* found.
*/
public static String findAccountPrefix(
BundleContext bundleContext, AccountID accountID, String sourcePackageName) {
ServiceReference confReference =
bundleContext.getServiceReference(ConfigurationService.class.getName());
ConfigurationService configurationService =
(ConfigurationService) bundleContext.getService(confReference);
// first retrieve all accounts that we've registered
List<String> storedAccounts =
configurationService.getPropertyNamesByPrefix(sourcePackageName, true);
// find an account with the corresponding id.
for (String accountRootPropertyName : storedAccounts) {
// unregister the account in the configuration service.
// all the properties must have been registered in the following
// hierarchy:
// net.java.sip.communicator.impl.protocol.PROTO_NAME.ACC_ID.PROP_NAME
String accountUID =
configurationService.getString(
accountRootPropertyName // node id
+ "."
+ ACCOUNT_UID); // propname
if (accountID.getAccountUniqueID().equals(accountUID)) {
return accountRootPropertyName;
}
}
return null;
}
/**
* The method stores the specified account in the configuration service under the package name of
* the source factory. The restore and remove account methods are to be used to obtain access to
* and control the stored accounts.
*
* <p>In order to store all account properties, the method would create an entry in the
* configuration service corresponding (beginning with) the <tt>sourceFactory</tt>'s package name
* and add to it a unique identifier (e.g. the current miliseconds.)
*
* @param accountID the AccountID corresponding to the account that we would like to store.
* @param isModification if <tt>false</tt> there must be no such already loaded account, it
* <tt>true</tt> ist modification of an existing account. Usually we use this method with
* <tt>false</tt> in method installAccount and with <tt>true</tt> or the overridden method in
* method modifyAccount.
*/
protected void storeAccount(AccountID accountID, boolean isModification) {
if (!isModification && getAccountManager().getStoredAccounts().contains(accountID)) {
throw new IllegalStateException(
"An account for id " + accountID.getUserID() + " was already loaded!");
}
try {
getAccountManager().storeAccount(this, accountID);
} catch (OperationFailedException ofex) {
throw new UndeclaredThrowableException(ofex);
}
}
/**
* Saves the password for the specified account after scrambling it a bit so that it is not
* visible from first sight (Method remains highly insecure).
*
* <p>TODO Delegate the implementation to {@link AccountManager} because it knows the format in
* which the password (among the other account properties) is to be saved.
*
* @param bundleContext a currently valid bundle context.
* @param accountID the <tt>AccountID</tt> of the account whose password is to be stored
* @param password the password to be stored
* @throws IllegalArgumentException if no account corresponding to <tt>accountID</tt> has been
* previously stored.
* @throws OperationFailedException if anything goes wrong while storing the specified
* <tt>password</tt>
*/
protected void storePassword(BundleContext bundleContext, AccountID accountID, String password)
throws IllegalArgumentException, OperationFailedException {
String accountPrefix = findAccountPrefix(bundleContext, accountID, getFactoryImplPackageName());
if (accountPrefix == null) {
throw new IllegalArgumentException(
"No previous records found for account ID: "
+ accountID.getAccountUniqueID()
+ " in package"
+ getFactoryImplPackageName());
}
CredentialsStorageService credentialsStorage =
ServiceUtils.getService(bundleContext, CredentialsStorageService.class);
if (!credentialsStorage.storePassword(accountPrefix, password)) {
throw new OperationFailedException(
"CredentialsStorageService failed to storePassword",
OperationFailedException.GENERAL_ERROR);
}
}
/**
* 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;
}
}