/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2005 Sun Microsystems Inc. All Rights Reserved
*
* The contents of this file are subject to the terms
* of the Common Development and Distribution License
* (the License). You may not use this file except in
* compliance with the License.
*
* You can obtain a copy of the License at
* See the License for the specific language governing
* permission and limitations under the License.
*
* When distributing Covered Code, include this CDDL
* Header Notice in each file and include the License file
* at opensso/legal/CDDLv1.0.txt.
* If applicable, add the following below the CDDL Header,
* with the fields enclosed by brackets [] replaced by
* your own identifying information:
* "Portions Copyrighted [year] [name of copyright owner]"
*
* $Id: OrganizationConfigManager.java,v 1.31 2010/01/20 17:01:36 veiming Exp $
*
* Portions Copyrighted 2011-2016 ForgeRock AS.
*/
/**
* The class <code>OrganizationConfigManager</code> provides interfaces to
* manage an organization's configuration data. It provides interfaces to create
* and delete organizations, service attributes for organizations and service
* configuration parameters.
* <p>
* The organization configuration can be managed in a hierarchical manner, and a
* forward slash "/" will be used to separate the name hierarchy. Hence the root
* of the organization hierarchy will be represented by a single forward slash
* "/", and sub-organizations will be separated by "/". For example "/a/b/c"
* would represent a "c" sub-organization within "b" which would be a
* sub-organization of "a".
*
* @supported.all.api
*/
public class OrganizationConfigManager {
// Instance variables
// set the special characters which are not in realm names.
"sun-idrepo-amSDK-config-copyconfig-enabled";
private boolean copyOrgInitialized;
private boolean copyOrgEnabled;
// sunOrganizationAlias in org DIT.
// associatedDomain in org DIT.
// sunPreferredDomain in org DIT.
// inetDomainStatus in org DIT.
static {
}
/**
* Constructor to obtain an instance of
* <code>OrganizationConfigManager
* </code> for an organization by providing
* an authenticated identity of the user. The organization name would be "/"
* seperated to represent organization hierarchy.
*
* @param token
* single sign on token of authenticated user identity.
* @param orgName
* name of the organization. The value of <code>null
* </code> or
* "/" would represent the root organization.
*
* @throws SMSException
* if an error has occurred while getting the instance of
* <code>OrganizationConfigManager
* </code>.
*/
throws SMSException {
// Copy instance variables
// Instantiate and validate
try {
if (migratedTo70 && !registeredForConfigNotifications) {
registeredForConfigNotifications = true;
}
} catch (SMSException s) {
+ "constructor. Unable to "
+ "construct ServiceConfigManager for idRepoService ", s);
}
throw s;
} catch (SSOException ssoe) {
}
if (coexistMode) {
if (orgNamingAttrInLegacyMode == null) {
}
}
}
/**
* Returns the fully qualified name of the
* organization from the root
*
* @return the name of the organization
*/
return (orgName);
}
/**
* Returns the services configured for the organization.
*
* @return service names configured for the organization.
* @throws SMSException
* if there is an error accessing the data store to read the
* configured services.
*
* @deprecated This method has been deprecated, use <code>
* getAssignedServices()</code>
* instead.
*/
return (getAssignedServices());
}
/**
* Returns a set of service schemas to be used for
* creation of an organization. The service schemas contain a list of
* attributes and their schema, and will be provided as
* <code>ServiceSchema</code>.
*
* @return Set of <code>ServiceSchema</code> to be used for creation of an
* organization.
* @throws SMSException
* if there is an error accessing the data store to read the
* service schemas.
*/
// Loop through the services and determine the
// organization creation schemas
try {
}
}
} catch (SSOException ssoe) {
+ " unable to get service schema", ssoe);
}
return (serviceSchemaSet);
}
/**
* Creates a sub-organization under the current
* organization and sets the specified attributes. The sub-organization
* created can be only one level below the current organization. For
* multiple levels this method must be called recursively with the
* corresponding <code>OrganizationConfigManager
* </code>. The organization
* name must not have forward slash ("/"). For eg., the actual organization
* seperator here. The attributes for the organization can be <code>
* null</code>;
* else would contain service name as the key and another <code>Map</code>
* as the value that would contain the key-values pair for the services.
*
* @param subOrgName
* the name of the sub-organization.
* @param attributes
* Map of attributes for the organization per service. The
* parameter Map attributes contains another Map as its value,
* which then has attribute names and values. The way it is
* arranged is: Map::attributes --> Key: String::ServiceName
* Value: Map::svcAttributes Map::svcAttributes --> Key:
* String::AttributeName Value: Set::AttributeValues
*
* @return organization config manager of the newly created
* sub-organization.
* @throws SMSException
* if creation of sub-organization failed, or if creation of
* sub-organization is attempted when configuration is not
* migrated to realms.
*/
/*
* Since the "Map attributes" can contain more than one service name,
* creation of the sub organization is be achieved in 2 steps. i) create
* the sub-organization without the attributes ii) for the service names
* in the Map call setAttributes(...)
*/
boolean orgExists = false;
try {
// Check if realm exists, this throws SMSException
// if realm does not exist
// This is to avoid duplicate creation of realms.
+ "createSubOrganization() " + "Realm Already Exists.. "
+ subOrgDN);
orgExists = true;
} catch (SMSException smse) {
try {
} catch (SSOException e) {
"createSubOrganization:", e);
}
if (!orgExists) {
SMSEntry.debug.message("OrganizationConfigManager::createSubOrganization() New Realm, creating realm: {} - {}", subOrgName, smse);
}
}
if (orgExists) {
"sms-organization_already_exists1",
args));
}
while (st.hasMoreTokens()) {
"createSubOrganization() : Invalid realm name: "+
"createSubOrganization() : Detected invalid chars: "+obj);
}
}
// If in legacy mode or (realm mode and copy org enabled)
// Create the AMSDK organization first
}
}
// Update the attributes
// If in coexistMode and serviceName is idRepoService
// the following call sets the attributes to AMSDK organization also.
.hasNext();) {
}
}
}
if (realmEnabled) {
try {
} catch (IdRepoException ide) {
"createSubOrganization:", ide);
}
}
// If in realm mode and not in legacy mode, default services needs
// to be added.
if (realmEnabled && !coexistMode) {
}
// If in realm mode and copy org enabled, default services needs
// amSDKOrgName/OpenAM Organization is updated with the
// new suborg dn.
if (realmEnabled && isCopyOrgEnabled()) {
ServiceConfig s =
if (s != null) {
try {
}
break;
}
} catch (SSOException ssoe) {
"createSubOrganization:", ssoe);
}
}
}
if (realmEnabled) {
try {
if (coexistMode) {
} else {
}
} catch (SSOException ssoe) {
}
} catch (SMSException smse) {
}
} catch (DelegationException de) {
}
}
}
// Return the newly created organization config manager
return (ocm);
}
}
}
subOrgName + " - clashes with REST endpoint");
}
}
/**
* Returns the names of all sub-organizations.
*
* @return set of names of all sub-organizations.
* @throws SMSException
* if there is an error accessing the data store to read the
* sub-organization names.
*/
try {
return (getSubOrganizationNames("*", false));
} catch (SMSException s) {
+ "getSubOrganizationNames() Unable to "
+ "get sub organization names ", s);
throw s;
}
}
/**
* Returns the names of all peer-organizations.
*
* @return set of names of all peer-organizations.
* @throws SMSException
* if there is an error accessing the data store to read the
* peer-organization names.
*/
if (realmEnabled) {
try {
} catch (SMSException s) {
+ "getPeerOrganizationNames() Unable to "
+ "get Peer organization names ", s);
}
throw s;
}
}
return (getPeerSet);
}
/**
* Returns names of sub-organizations matching the
* given pattern. If the parameter <code>recursive</code> is set to
* <code>true</code>, search will be performed for the entire sub-tree.
* The pattern can contain "*" as the wildcard to represent zero or more
* characters.
*
* @param pattern
* pattern that will be used for searching, where "*" will be the
* wildcard.
* @param recursive
* if set to <code>true</code> the entire sub-tree will be
* searched for the organization names.
* @return names of sub-organizations matching the pattern.
* @throws SMSException
* if there is an error accessing the data store to read the
* sub-organization names.
*/
throws SMSException {
try {
if (realmEnabled) {
recursive));
} else {
// Must be in coexistence mode
}
} catch (SMSException s) {
+ "getSubOrganizationNames(String pattern, "
+ "boolean recursive) Unable to get sub organization "
+ "names for filter: " + pattern, s);
throw s;
}
}
/**
* Deletes the given sub-organization. If the
* parameter <code>recursive</code> is set to <code>true</code>, then
* the suborganization and the sub-tree will be deleted.
*
* If the parameter <code>recursive</code> is set to <code>false</code>
* then the sub-organization shall be deleted provided it is the leaf node.
* If there are entries beneath the sub-organization and if the parameter
* <code>recursive</code> is set to <code>false</code>, then an
* exception is thrown that this sub-organization cannot be deleted.
*
* @param subOrgName
* sub-organization name to be deleted.
* @param recursive
* if set to <code>true</code> the entire sub-tree will be
* deleted.
* @throws SMSException
* if the sub-organization name cannot be found, or if there are
* entries beneath the sub-organization and if the parameter
* <code>recursive</code> is set to <code>false</code>.
*/
throws SMSException {
// Should not delete the root realm, should throw exception if
// attempted.
"OrganizationConfigManager: deleteSubOrganization(" +
"sms-cannot_delete_rootsuffix",parms));
}
// Delete the sub-organization
//set the filter "*" to be passed for the search.
if (realmEnabled) {
try {
subOrgDN);
}
if (!recursive) {
// Check if there are sub organization entries
// and if exist
// throw exception that this sub organization cannot be
// deleted.
.getString("sms-entries-exists"),
"sms-entries-exists"));
}
}
// Obtain the SMSEntry for the suborg and
// sub tree and delete it.
} catch (SSOException ssoe) {
"OrganizationConfigManager: deleteSubOrganization(" +
"String subOrgName, boolean recursive) Unable to " +
"delete sub organization ", ssoe);
}
}
// If in legacy mode or (realm mode and copy org enabled)
// delete the corresponding organization.
SMSEntry.getAMSdkBaseDN())) {
}
}
}
}
/**
* Returns the <code>OrganizationConfigManager</code>
* for the given organization name.
*
* @param subOrgName
* the name of the organization.
* @return the configuration manager for the given organization.
*
* @throws SMSException
* if the organization name cannot be found or user doesn't have
* access to that organization.
*/
throws SMSException {
// Normalize sub organization name
orgDN)));
}
/**
* Returns the organization creation attributes for
* the service.
*
* @param serviceName
* name of the service.
* @return map of organization creation attribute values for service
* @throws SMSException
* if there is an error accessing the data store to read the
* attributes of the service.
*/
if (serviceName == null) {
return (Collections.EMPTY_MAP);
}
// Attributes can be obtained only if DIT is migrated to AM 7.0
if (migratedTo70) {
// Lowercase the service name
try {
orgDN);
(realmEnabled && isCopyOrgEnabled())) {
// Since AMSDK org notifications will not be
// obtained, the entry must be read again
}
// Remove the serviceName and '-' and return only
// the attribute name,value.
if (!serviceName.isEmpty()) {
} else {
}
if (attrValues == null) {
attrValues = new HashMap();
}
}
}
}
} catch (SSOException ssoe) {
+ "getAttributes(String serviceName) Unable to "
+ "get Attributes", ssoe);
}
}
// If in coexistMode and serviceName is idRepoService
// get attributes from AMSDK organization
&& serviceName
}
}
}
if (attrValues == null) {
} else {
}
}
}
/**
* Builds and returns the appropriate Set for the attributes to be
* merged from org and realm if the system is
* in intrusive mode (Both org DIT and realm DIT are present).
* This happens when the Copy Config flag is enabled.
*/
}
return (resultSet);
}
/**
* Adds organization attributes for the service. If
* the attribute already exists, the values will be appended to it, provided
* it is a multi-valued attribute. It will throw exception if we try to add
* a value to an attribute which has the same value already.
*
* @param serviceName
* name of the service.
* @param attrName
* name of the attribute.
* @param values
* values for the attribute.
* @throws SMSException
* if we try to add a value to an attribute which has the same
* value already.
*/
return;
}
if (migratedTo70) {
// Lowercase the servicename
try {
orgDN);
}
serviceName, token);
.getString("sms-SMSSchema_service_notfound"),
"sms-SMSSchema_service_notfound"));
}
}
} catch (SSOException ssoe) {
+ "to add Attribute Values", ssoe);
}
}
// If in coexistMode and serviceName is idRepoService
// add the attributes to AMSDK organization
if (coexistMode
&& serviceName
}
}
/**
* service. If the attributes already exists, the given attribute values
* will replace them.
*
* @param serviceName
* name of the service.
* @param attributes
* attribute-values pairs.
* @throws SMSException
* if the serviceName cannot be found.
*/
throws SMSException {
if (serviceName == null) {
return;
}
if (migratedTo70) {
// Lowercase the serviceName
try {
orgDN);
}
// Validate the attributes
serviceName, token);
// Normalize the attributes with service name
/*
* To make the attributes qualified by service name we
* prefix the attribute names with the service name.
*/
}
// Look for old attrs. in the storage and add them too.
}
// Set the attributes in SMSEntry
// Add these OCs only for SunOne DS. Do not add the
// OCs for Active Directory.
// Will get WILL_NOT_PERFORM in AD.
) {
// This is for storing organization attributes
boolean exists = false;
{
// OC needs to be added outside the for loop
// else will throw concurrent mod exception
exists = true;
break;
}
}
if (!exists) {
}
} else if (e.getDN().startsWith(
// This is for storing organization attributes in
// organizations created via sdk through realm
// console.
boolean rsvcExists = false;
n++) {
if (vals[n].equalsIgnoreCase(
{
// OC needs to be added outside the for loop
// else will throw concurrent mod exception
rsvcExists = true;
break;
}
}
if (!rsvcExists) {
}
}
}
// Save in backend data store and refresh the cache
}
} catch (SSOException ssoe) {
+ "to set Attributes", ssoe);
}
}
// If in coexistMode and serviceName is idRepoService
// set the attributes to AMSDK organization
&& serviceName
}
}
/**
* Removes the given organization creation attribute
* for the service.
*
* @param serviceName
* name of service.
* @param attrName
* name of attribute.
* @throws SMSException
* if the organization attribute for the service to be removed
* cannot be found, or if the service name cannot be found.
*/
throws SMSException {
return;
}
if (migratedTo70) {
try {
orgDN);
}
+ attrName);
} catch (SSOException ssoe) {
+ "to remove Attribute", ssoe);
}
}
// If in coexistMode and serviceName is idRepoService
// remove the attributes to AMSDK organization
if (coexistMode
&& serviceName
}
}
/**
* Removes the given organization creation attribute
* values for the service.
*
* @param serviceName
* name of service.
* @param attrName
* name of attribute.
* @param values
* attribute values to be removed.
* @throws SMSException
* if the organization attribute for the service to be removed
* cannot be found, or if the service name cannot be found, or
* if the value cannot be removed.
*/
return;
}
if (migratedTo70) {
try {
orgDN);
}
serviceName, token);
} catch (SSOException ssoe) {
+ "to remove Attribute Values", ssoe);
}
}
// If in coexistMode and serviceName is idRepoService
// remove the attributes to AMSDK organization
if (coexistMode
&& serviceName
}
}
/**
* Returns the service configuration object for the
* given service name.
*
* @param serviceName
* name of a service.
* @return service configuration object for the service.
* @throws SMSException
* if there is an error accessing the data store to read the
* service configuration, or if the service name cannot be
* found.
*/
throws SMSException {
try {
token);
return (scg);
} catch (SSOException ssoe) {
+ "get Service Config", ssoe);
}
}
try {
} catch (SSOException ssoe) {
}
}
/**
* Adds a service configuration object for the given
* service name for this organization. If the service has been already added
* a <code>SMSException</code> will be thrown.
*
* @param serviceName
* name of the service.
* @param attributes
* service configuration attributes.
* @return service configuration object.
* @throws SMSException
* if the service configuration has been added already.
*/
throws SMSException {
try {
null);
serviceName, token);
} else {
.getString("sms-service_already_exists1")));
}
} catch (SSOException ssoe) {
+ "add Service Config", ssoe);
}
}
/**
* Removes the service configuration object for the
* given service name for this organization.
*
* @param serviceName
* name of the service.
* @throws SMSException
* if the service name cannot be found, or not added to the
* organization.
*/
try {
token);
} catch (SSOException ssoe) {
+ "delete Service Config", ssoe);
}
}
/**
* Registers for changes to organization's
* configuration. The object will be called when configuration for this
* organization is changed.
*
* @param listener
* callback object that will be invoked when organization
* configuration has changed
* @return an ID of the registered listener.
*/
}
/**
* Removes the listener from the organization for the
* given listener ID. The ID was issued when the listener was registered.
*
* @param listenerID
* the listener ID issued when the listener was registered
*/
}
/**
* Returns normalized DN for realm model
*/
// Return orgDN if subOrgName is either null or empty
return (orgDN);
}
+ "normalizeDN()-subOrgName " + subOrgName);
}
if (ndx == -1) {
// Check for baseDN
}
if (ndx > 0) {
}
+ "normalizeDN()-slashConvertedString: " + tmp);
}
} else {
if (dx >= 0) {
} else {
}
}
} else {
}
} else {
if (coexistMode) {
} else {
}
}
+ "normalizeDN() suborgdn " + subOrgDN);
}
return (subOrgDN);
}
/**
* Returns all service names configured for AM
*/
// Get the service names from ServiceManager
}
/**
* Returns a set of service names that can be assigned
* to a realm. This set excludes name of services that are already assigned
* to the realm and services that are required for the existence of a realm.
*
* @return a set of service names that can be assigned to a realm.
* @throws SMSException
* if there is an error accessing the data store to read the
* service configuration
*/
// Get all service names, and remove the assigned services
// Set containing service names that has organization schema
try {
.hasNext();) {
// Need to check if the user has permission
// Need to construct
// "ou=default,ou=organizationconfig,ou=1.0,ou="
// Append service name, and org name
d.append(serviceName);
}
try {
// The function will throw exception if
// user does not have permissions
} catch (SMSException smse) {
if (smse.getExceptionCode() !=
{
throw (smse);
}
}
}
}
// Need to remove mandatory services
// %%% TODO. Need to have SMS Service with this information
// orgSchemaServiceNames.removeAll(getMandatoryServices());
} catch (SSOException ssoe) {
+ "getAssignableServices(): SSOException", ssoe);
}
// Remove assigned services
return (answer);
}
/**
* Returns a set of service names that are assigned to
* a realm.
*
* @return a set of service names that are assigned to a realm.
* @throws SMSException
* if there is an error accessing the data store to read the
* service configuration
*/
return (getAssignedServices(true));
}
/**
* Returns a set of service names that are assigned to a realm.
*
* @param includeMandatory
* <code>true</code> to include mandatory service names.
* @return a set of service names that are assigned to a realm.
* @throws SMSException
* if there is an error accessing the data store to read the
* service configuration
*/
throws SMSException {
if (coexistMode) {
// Get assigned services from OrgConfigViaAMSDK
} else {
// Get assigned service names from OrganizationConfigManagerImpl
}
if (!includeMandatory) {
// Get services assigned by default
}
return (assignedServices);
}
/**
* Assigns the given service to the orgnization with
* the respective attributes. If the service has been already added a <code>
* SMSException</code>
* will be thrown.
*
* @param serviceName
* name of the service
* @param attributes
* service configuration attributes
* @throws SMSException
* if the service configuration has been added already.
*/
throws SMSException {
}
/**
* Returns attributes configured for the service.
*
* @param serviceName
* name of the service
* @return a map of attributes for the service
* @throws SMSException
* if there is an error accessing the data store to read the
* service configuration, or if the service name cannot be
* found.
*/
"OrganizationConfigManager.getServiceAttributes() Unable " +
"to get service attributes. ");
"sms-no-organization-schema",
args));
}
return (scg.getAttributes());
}
/**
* Unassigns the service from the organization.
*
* @param serviceName
* name of the service
* @throws SMSException
* if the service name cannot be found or assigned, or if the
* service is a mandatory service.
*/
// if (coexistMode) {
// amsdk.unassignService(serviceName);
// } else {
// }
}
/**
* Sets the attributes related to provided service.
* The assumption is that the service is already assigned to the
* organization. The attributes for the service are validated against the
* service schema.
*
* @param serviceName
* name of the service
* @param attributes
* attributes of the service
* @throws SMSException
* if the service name cannot be found or not assigned to the
* organization.
*/
throws SMSException {
try {
} catch (SSOException ssoe) {
+ "SSOException in modify service ", ssoe);
}
}
return OrgConfigViaAMSDK.getNamingAttrForOrg();
}
/**
* Returns the <code>OrganizationConfigManager</code>
* of the parent for the given organization name.
*
* @return the configuration manager of the parent for the given
* organization.
* @throws SMSException
* if user doesn't have access to that organization.
*/
throws SMSException {
return (this);
}
+ "getParentOrgConfigManager() parentDN : " + parentDN);
}
}
}
return ocm;
}
/**
* Loads default services to a newly created realm
*/
// Check if DIT has been migrated to 7.0
if (!migratedTo70) {
return;
}
// Load the default services automatically
if (defaultServices == null) {
// There are no services to be loaded
return;
}
+ "::loadDefaultServices " + "assignedServices : "
+ assignedServices);
}
boolean doAuthServiceLater = false;
boolean doAuthHttpBasicLater = false;
// Copy service configuration
doAuthServiceLater = true;
continue;
} else if (serviceName.equals(
doAuthHttpBasicLater = true;
continue;
}
} else if (doAuthHttpBasicLater) {
doAuthHttpBasicLater = false;
} else if (doAuthServiceLater) {
doAuthServiceLater = false;
}
"::loadDefaultServices:ServiceName " + serviceName);
}
try {
.message("OrganizationConfigManager"
+ "::loadDefaultServices "
+ "Copying service from parent: "
+ serviceName);
}
// Copy sub-configurations, if any
}
} catch (SSOException ssoe) {
"OrganizationConfigManager.loadDefaultServices " +
"SSOException in loading default services ",
ssoe);
}
}
}
}
/**
* Registers default services to newly created suborganizations.
*/
{
try {
"registerSvcsForOrg. "+
"defaultServices : " + defaultServices);
}
// Register the default services to the newly created orgs,so
// they will be marked with the OC sunRegisteredServiceName.
if (defaultServices != null) {
"registerSvcsForOrg:assignedServices: " +
}
SMSEntry.getAMSdkBaseDN())) {
} else {
}
"OrganizationConfigManager::"+
"registerSvcsForOrg:ServiceName : " +
}
}
}
}
} catch (SMSException smse) {
// Unable to load default services
"registerSvcsForOrg. " +
"SMSException in registering services: ", smse);
}
}
}
/**
* Copies service configurations recursively from source to destination
*/
throws SMSException, SSOException {
if (subSchema.isRealmCloneable()) {
to.addSubConfig(subConfigName, scf.getSchemaID(), scf.getPriority(), scf.getAttributesWithoutDefaults());
}
}
}
/**
* Determines whether an organization ought to be created for each
* realm in realm only mode of installation based on the boolean flag
* in amSDK plugin.
* This requirement is for portal customers.
*/
protected boolean isCopyOrgEnabled() {
if (copyOrgInitialized) {
return (copyOrgEnabled);
}
"in isCopyOrgEnabled() ");
}
// Check if AMSDK is configured for the realm
try {
if (s != null) {
"CopyOrgEnabled. SubConfig is NULL: " +
return (false);
}
// Get the amsdkOrgName from the amSDKRepo to build
// OrgConfigViaSDK instance.
(amSDKOrgDN !=null) ) {
amSDKOrgDN, orgDN);
if (orgNamingAttrInLegacyMode == null) {
}
copyOrgEnabled = true;
}
break;
}
}
}
}
}
} catch (SSOException sse) {
// Use default values i.e., false
"isCopyOrgEnabled() Unable to get service: " +
}
} catch (SMSException e) {
// Use default values i.e., false
"isCopyOrgEnabled() Unable to get service: " +
}
}
copyOrgInitialized = true;
"copyOrgEnabled == " + copyOrgEnabled);
}
return (copyOrgEnabled);
}
static void initializeFlags() {
}
// Instantiate the OrgConfigImpl and cache it
try {
} catch (SSOException ssoe) {
}
}
}
// Call ServiceManager to notify
// If naming service has changed, reload the AM Servers
}
}
try {
} catch (SSOException ssoe) {
+ "globalConfigChanged ", ssoe);
} catch (SMSException smse) {
+ "globalConfigChanged ", smse);
}
}
}
// Reset the cached configuration in OrgConfigViaAMSDK
{
}
}
}
// ******* Static Variables ************
// To determine if notification object has been registered for config
// changes
private static boolean registeredForConfigNotifications;
// Realm & Co-existence modes
private static boolean realmEnabled;
private static boolean coexistMode;
private static boolean migratedTo70;
}