import org.wso2.carbon.kernel.startupresolver.RequiredCapabilityListener; //导入依赖的package包/类
/**
 * Adds the available {@code RequiredCapabilityListener} OSGi service to the specified startup component.
 * <p>
 * This service is required to notify the component when all of its required capabilities are available.
 *
 * @param listener      {@code RequiredCapabilityListener} service object.
 * @param componentName the component name to which this listener is added.
 * @param bundle        the bundle from which this listener service is registered.
 */
void addRequiredCapabilityListener(RequiredCapabilityListener listener, String componentName, Bundle bundle) {
    StartupComponent startupComponent = startupComponentMap.get(componentName);
    if (startupComponent == null) {
        logger.warn("Adding a RequiredCapabilityListener from bundle({}:{}), but specified startup component is " +
                "not available, component-name: {}", bundle.getSymbolicName(), bundle.getVersion(), componentName);
        return;
    }

    if (startupComponent.getListener() != null) {
        logger.warn("Duplicate RequiredCapabilityListener detected. Existing RequiredCapabilityListener for " +
                        "startup component {}. New RequiredCapabilityListener from bundle({}:{}).",
                componentName,
                bundle.getSymbolicName(),
                bundle.getVersion());
        return;
    }

    if (logger.isDebugEnabled()) {
        logger.debug("Adding available RequiredCapabilityListener with the componentName {} from bundle({}:{})",
                componentName, bundle.getSymbolicName(), bundle.getVersion());
    }
    startupComponent.setListener(listener);
}
 

import org.wso2.carbon.kernel.startupresolver.RequiredCapabilityListener; //导入依赖的package包/类
void notifySatisfiableComponents() {
    getComponents(StartupComponent::isSatisfiable)
            .forEach(startupComponent -> {

                if (logger.isDebugEnabled()) {
                    logger.debug("Notifying RequiredCapabilityListener of component {} from bundle({}:{}) " +
                                    "since all the required capabilities are available",
                            startupComponent.getName(),
                            startupComponent.getBundle().getSymbolicName(),
                            startupComponent.getBundle().getVersion());
                }

                startupComponent.setSatisfied(true);
                RequiredCapabilityListener capabilityListener = startupComponent.getListener();

                try {
                    capabilityListener.onAllRequiredCapabilitiesAvailable();
                } catch (RuntimeException e) {
                    logger.error("Runtime Exception occurred while calling onAllRequiredCapabilitiesAvailable of "
                            + "component " + startupComponent.getName(), e);
                }
            });
}
 

import org.wso2.carbon.kernel.startupresolver.RequiredCapabilityListener; //导入依赖的package包/类
/**
 * Returns a {@link List} of OSGi service keys required by startup components.
 *
 * @param startupComponentManager instance of the StartupComponentManager
 * @return a {@link List} of OSGi service keys
 */
private List<String> getRequiredServiceList(StartupComponentManager startupComponentManager) {
    List<StartupComponent> pendingComponents = startupComponentManager.getComponents(StartupComponent::isPending);
    List<String> requiredServiceList = pendingComponents
            .stream()
            .flatMap(startupComponent -> startupComponent.getRequiredServices().stream())
            .distinct()
            .collect(Collectors.toList());

    // We need to track RequiredCapabilityListener services as well as CapabilityProvider service.
    requiredServiceList.add(RequiredCapabilityListener.class.getName());
    requiredServiceList.add(CapabilityProvider.class.getName());
    return requiredServiceList;
}
 

import org.wso2.carbon.kernel.startupresolver.RequiredCapabilityListener; //导入依赖的package包/类
public RequiredCapabilityListener getListener() {
    return listener;
}
 

import org.wso2.carbon.kernel.startupresolver.RequiredCapabilityListener; //导入依赖的package包/类
public void setListener(RequiredCapabilityListener listener) {
    this.listener = listener;
}
 

import org.wso2.carbon.kernel.startupresolver.RequiredCapabilityListener; //导入依赖的package包/类
@Override
public Object addingService(ServiceReference<Object> reference) {
    Object serviceObject = DataHolder.getInstance().getBundleContext().getService(reference);
    String serviceInterfaceClassName = ((String[]) reference.getProperty(OBJECT_CLASS))[0];
    String serviceImplClassName = serviceObject.getClass().getName();
    Bundle bundle = reference.getBundle();

    if (RequiredCapabilityListener.class.getName().equals(serviceInterfaceClassName)) {
        String componentKey = getNonEmptyStringAfterTrim((String) reference.getProperty(COMPONENT_NAME))
                .orElseThrow(() -> new StartOrderResolverException(COMPONENT_NAME + " value is missing in " +
                        "the services registered with the key " + serviceInterfaceClassName + ", " +
                        "implementation class name is " + serviceImplClassName));

        startupComponentManager.addRequiredCapabilityListener(
                (RequiredCapabilityListener) serviceObject, componentKey, reference.getBundle());

    } else if (CapabilityProvider.class.getName().equals(serviceInterfaceClassName)) {
        String capabilityName = getNonEmptyStringAfterTrim((String) reference.getProperty(CAPABILITY_NAME))
                .orElseThrow(() -> new StartOrderResolverException(CAPABILITY_NAME + " value is missing in " +
                        "the services registered with the key " + serviceInterfaceClassName + ", " +
                        "implementation class name is " + serviceImplClassName));

        CapabilityProviderCapability capabilityProvider = new CapabilityProviderCapability(
                CapabilityProvider.class.getName(),
                Capability.CapabilityType.OSGi_SERVICE,
                Capability.CapabilityState.AVAILABLE,
                capabilityName.trim(),
                bundle);

        startupComponentManager.addExpectedOrAvailableCapabilityProvider(capabilityProvider);

        CapabilityProvider provider = (CapabilityProvider) serviceObject;
        IntStream.range(0, provider.getCount())
                .forEach(count -> startupComponentManager.addExpectedCapability(
                        new OSGiServiceCapability(
                                capabilityName.trim(),
                                Capability.CapabilityType.OSGi_SERVICE,
                                Capability.CapabilityState.EXPECTED,
                                bundle,
                                true)));
    } else {
        if (Boolean.TRUE.equals(reference.getProperty(SKIP_CARBON_STARTUP_RESOLVER))) {
            logger.debug("Skipping tracking of service {} which implements {}.", serviceImplClassName,
                         serviceInterfaceClassName);
            return null;
        }

        logger.debug("Updating indirect dependencies in components for interface={} via the implementation={}",
                serviceInterfaceClassName, serviceImplClassName);
        startupComponentManager.updateCapability(new OSGiServiceCapability(
                serviceInterfaceClassName,
                Capability.CapabilityType.OSGi_SERVICE,
                Capability.CapabilityState.AVAILABLE,
                bundle,
                false));
    }

    return serviceObject;
}