import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * 
 * is invoked when new provider message consumer is registered in the OSGi context.
 * 
 * @param consumer
 *            registered provider message consumer
 */
@Bind(aggregate = true, optional = true)
public void bindMessageConsumer(ProviderMessageConsumer consumer) {
    try {
        MessageConsumer jmsConsumer = getSession().createConsumer(
                getDestination(),
                getMessageTypeSelector(consumer.getConsumedMessageType(),
                        consumer.getConsumedMessageVersion()));
        JMSMessageConsumerImpl cntJMSMessageConsumer = new JMSMessageConsumerImpl();
        cntJMSMessageConsumer.setCommunoteMessageConsumer(consumer);
        cntJMSMessageConsumer.setJmsMessageConsumer(jmsConsumer);
        cntJMSMessageConsumer.setJmsSender(jmsSender);
        jmsMessageConsumers.put(consumer, cntJMSMessageConsumer);
        cntJMSMessageConsumer.start();
        LOG.debug("JMS message consumer has been instantiated and bound.");
    } catch (JMSException e) {
        LOG.error("JMS message consumer has not been instantiated. "
                + consumer.getClass().getName(), e);
    }
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * HTTP service ready
 * 
 * MOD_BD_20170724
 * 
 * @param aHttpService
 *            The bound service
 * @param aServiceProperties
 *            The HTTP service properties
 */
@Bind(id = IPOJO_ID_HTTP)
private void bindHttpService(final HttpService aHttpService,
        final Map<?, ?> aServiceProperties) {

    final Object rawPort = aServiceProperties.get(HTTP_SERVICE_PORT);

    if (rawPort instanceof Number) {
        // Get the integer
    	pHttpDefaultPort = ((Number) rawPort).intValue();

    } else if (rawPort instanceof CharSequence) {
        // Parse the string
    	pHttpDefaultPort = Integer.parseInt(rawPort.toString());

    } else {
        // Unknown port type
        pLogger.log(LogService.LOG_WARNING, "Couldn't read access port="
                + rawPort);
        pHttpDefaultPort = -1;
    }

    pLogger.log(LogService.LOG_INFO, String.format("Default Http port provided by Http Service [%s]",
    				pHttpDefaultPort));
    
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * A message listener has been bound
 *
 * @param aListener
 *            A message listener
 * @param aReference
 *            The injected service reference
 */
@Bind(id = ID_LISTENERS, aggregate = true, optional = true)
protected void bindListener(final IMessageListener aListener,
		final ServiceReference<IMessageListener> aReference) {

	final Object rawFilters = aReference
			.getProperty(IConstants.PROP_FILTERS);
	String[] filters;
	if (rawFilters instanceof String) {
		// Single filter
		filters = new String[] { (String) rawFilters };

	} else if (rawFilters instanceof String[]) {
		// Copy the array
		final String[] givenFilters = (String[]) rawFilters;
		filters = Arrays.copyOf(givenFilters, givenFilters.length);

	} else {
		// Unreadable filters
		return;
	}

	addMessageListener(aListener, filters);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * A transport implementation has been bound
 *
 * @param aTransport
 *            A transport implementation
 * @param aReference
 *            The injected service reference
 */
@Bind(id = ID_TRANSPORTS, aggregate = true, optional = true)
protected void bindTransport(final ITransport aTransport,
		final ServiceReference<ITransport> aReference) {

	final String accessId = (String) aReference
			.getProperty(IConstants.PROP_ACCESS_ID);
	if (accessId == null || accessId.isEmpty()) {
		// Ignore invalid access IDs
		return;
	}

	synchronized (pTransports) {
		// Store the service
		pTransports.put(accessId, aTransport);

		if (pSvcRegistration == null) {
			// We have at least one service: provide our service
			pSvcRegistration = pContext.registerService(IHerald.class,
					this, null);
		}
	}
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * HTTP service ready
 * 
 * @param aHttpService
 *            The bound service
 * @param aServiceProperties
 *            The HTTP service properties
 */
@Bind(id = IPOJO_ID_HTTP)
private void bindHttpService(final HttpService aHttpService,
        final Map<?, ?> aServiceProperties) {

    final Object rawPort = aServiceProperties.get(HTTP_SERVICE_PORT);

    if (rawPort instanceof Number) {
        // Get the integer
        pHttpPort = ((Number) rawPort).intValue();

    } else if (rawPort instanceof CharSequence) {
        // Parse the string
        pHttpPort = Integer.parseInt(rawPort.toString());

    } else {
        // Unknown port type
        pLogger.log(LogService.LOG_WARNING, "Couldn't read access port "
                + rawPort);
        pHttpPort = -1;
    }
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * HTTP service ready: store its listening port
 *
 * @param aHttpService
 *            The bound service
 * @param aServiceProperties
 *            The HTTP service properties
 */
@Bind(id = IPOJO_ID_HTTP)
private void bindHttpService(final HttpService aHttpService,
        final Map<?, ?> aServiceProperties) {

    final Object rawPort = aServiceProperties.get(HTTP_SERVICE_PORT);

    if (rawPort instanceof Number) {
        // Get the integer
        pHttpPort = ((Number) rawPort).intValue();

    } else if (rawPort instanceof CharSequence) {
        // Parse the string
        pHttpPort = Integer.parseInt(rawPort.toString());

    } else {
        // Unknown port type
        pLogger.log(LogService.LOG_WARNING, "Couldn't read access port="
                + rawPort);
        pHttpPort = -1;
    }

    pLogger.log(LogService.LOG_INFO, "JABSORB-RPC endpoint bound to port="
            + pHttpPort);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Callback that binds a REST module.
 *
 * @param aApplication
 *            REST module
 */
@Bind(aggregate = true)
private void bind(IRestApplication aApplication) {
	pLogger.log(LogService.LOG_INFO, "Binding to a REST application.");
	boolean valid = false;
	synchronized (this) {
		if (this.pValid) {
			register(aApplication);
			valid = true;
		} else {
			this.pAwaiting.add(aApplication);
		}
	}
	pLogger.log(LogService.LOG_INFO, valid ? "Valid application."
			: "Invalid application.");
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Adds the given processor to the list of processors.
 * 
 * @param noteRenderingPreProcessor
 *            The processor.
 */
@Bind(id = "registerContentProcessor", optional = true, aggregate = true)
public void registerNoteContentPreProcessor(
        NoteContentRenderingPreProcessor noteRenderingPreProcessor) {
    ServiceLocator.findService(NoteRenderingPreProcessorManager.class).addProcessor(
            noteRenderingPreProcessor);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Adds the given processor to the list of processors.
 * 
 * @param noteRenderingPreProcessor
 *            The processor.
 */
@Bind(id = "registerProcessor", optional = true, aggregate = true)
public void registerNoteMetadataPreProcessor(
        NoteMetadataRenderingPreProcessor noteRenderingPreProcessor) {
    ServiceLocator.findService(NoteRenderingPreProcessorManager.class).addProcessor(
            noteRenderingPreProcessor);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Adds the given processor to the list of processors.
 * 
 * @param notePreProcessor
 *            The processor.
 */
@Bind(id = "noteStoringImmutableContentPreProcessorHook", optional = true, aggregate = true)
public void registerImmutablePreProcessor(
        NoteStoringImmutableContentPreProcessor notePreProcessor) {
    ServiceLocator.instance().getService(NoteStoringPreProcessorManager.class)
            .addProcessor(notePreProcessor);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Registers the Service.
 *
 * @param controller
 *            The controller.
 */
@Bind(id = "controllerRegistry", optional = true, aggregate = true)
public void register(Controller controller) {
    List<String> urlPatterns = new ArrayList<String>();
    UrlMapping mapping = controller.getClass().getAnnotation(UrlMapping.class);
    if (mapping != null) {
        urlPatterns.add(mapping.value());
        addAdministrationView(mapping, controller);
    }
    UrlMappings mappings = controller.getClass().getAnnotation(UrlMappings.class);
    if (mappings != null) {
        for (String urlMapping : mappings.mappings()) {
            urlPatterns.add(urlMapping);
        }
    }
    mapper.registerController(controller, urlPatterns);

    StartpageController startpageMarker = controller.getClass().getAnnotation(
            StartpageController.class);
    if (startpageMarker != null) {
        if (urlPatterns.size() == 0) {
            LOGGER.warn("Startpage marker ignored because no URL mapping is defined");
        } else {
            registerStartpageController(controller, urlPatterns.get(0));
        }
    } else {
        LOGGER.debug("No startpage marker found");
    }
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Registers the given filter.
 * 
 * @param permissionFilter
 *            The filter to register.
 */
@Bind(id = "registerFilter", optional = true, aggregate = true)
public void registerPermissionFilter(NotePermissionFilter permissionFilter) {
    ServiceLocator.instance().getService(NotePermissionManagement.class)
            .addPermissionFilter(permissionFilter);
    LOGGER.debug("Added note permission filter {}", permissionFilter.getClass().getName());
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Register a JS messages extension
 *
 * @param extension
 *            the extension to register
 * @param reference
 *            reference to the OSGI service
 */
@Bind(id = "registerJsMessagesExtension", aggregate = true, optional = true)
public void register(JsMessagesExtension extension, ServiceReference reference) {
    String symbolicName = reference.getBundle().getSymbolicName();
    JsMessagesRegistry registry = getMessagesRegistry();
    for (String category : extension.getJsMessageKeys().keySet()) {
        registry.addMessageKeys(symbolicName, category, extension.getJsMessageKeys().get(
                category));
    }
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Adds the given processor to the list of processors.
 * 
 * @param attachmentStoringPreProcessor
 *            The processor.
 */
@Bind(id = "registerAttachmentStoringPreProcessor", optional = true, aggregate = true)
public void registerAttachmentStoringPreProcessor(
        AttachmentStoringPreProcessor attachmentStoringPreProcessor) {
    ServiceLocator.instance().getService(ResourceStoringManagement.class)
            .addAttachmentStoringPreProcessor(attachmentStoringPreProcessor);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Method to register a filter.
 * 
 * @param filter
 *            The filter to register.
 */
@Bind(id = "registerFilter", optional = true, aggregate = true)
public void registerCommunoteAuthenticationFilter(CommunoteAuthenticationFilter filter) {
    AuthenticationManager authenticationManager = WebServiceLocator.instance()
            .getWebApplicationContext()
            .getBean("authenticationManager", AuthenticationManager.class);
    filter.setAuthenticationManager(authenticationManager);
    ServiceLocator.instance().getService(AuthenticationFilterManagement.class)
            .addFilter(filter);
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Bind the activity service
 * 
 * @param activityService
 *            the ActivityService service
 */
// using bind method because Requires annotation does not work (the service is null when
// accessing it - no idea why)
@Bind
public void bindService(ActivityService activityService) {
    this.activityService = activityService;
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * If there is a embedded configuration set it
 * 
 * @param embeddedConfiguration
 *            the configuration
 */
@Bind(optional = true)
public synchronized void bindEmbeddedConfiguration(
        ActiveMQEmbeddedConfiguration embeddedConfiguration) {
    this.embeddedConfiguration = embeddedConfiguration;
    if (callback != null) {
        callback.onConfigurationChanged();
    }
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Injects an available <tt>SimpleShape</tt> into the drawing frame.
 * 
 * @param name The name of the injected <tt>SimpleShape</tt>.
 * @param icon The icon associated with the injected <tt>SimpleShape</tt>.
 * @param shape The injected <tt>SimpleShape</tt> instance.
 **/
@Bind(aggregate=true)
public void bindShape(SimpleShape shape, Map attrs) {
  final DefaultShape delegate = new DefaultShape(shape);
  final String name = (String) attrs.get(SimpleShape.NAME_PROPERTY);
  final Icon icon = (Icon) attrs.get(SimpleShape.ICON_PROPERTY);
  
  if ( name == null || icon == null ) return;
  
  m_shapes.put(name, delegate);
  
  SwingUtils.invokeAndWait( new Runnable() {
    public void run() {
      JButton button = new JButton(icon);
      button.setActionCommand(name);
      button.setToolTipText(name);
      button.addActionListener(m_reusableActionListener);

      if (m_selected == null) {
        button.doClick();
      }

      m_toolbar.add(button);
      m_toolbar.validate();
      repaint();
    }      
  });
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * HTTP service ready
 *
 * @param aHttpService
 *            The bound service
 * @param aServiceProperties
 *            The HTTP service properties
 * @deprecated
 */
@Bind(id = IPOJO_ID_HTTP)
private void bindHttpService(final HttpService aHttpService,
        final Map<?, ?> aServiceProperties) {
	// MOD_BD_20160915 using HttpServiceAvailabilityChecker component to retrieve the right port
	/* 
    final Object rawPort = aServiceProperties.get(HTTP_SERVICE_PORT);

    if (rawPort instanceof Number) {
        // Get the integer
        pHttpPort = ((Number) rawPort).intValue();

    } else if (rawPort instanceof CharSequence) {
        // Parse the string
        pHttpPort = Integer.parseInt(rawPort.toString());

    } else {
        // Unknown port type
        pLogger.log(LogService.LOG_WARNING, "Couldn't read access port="
                + rawPort);
        pHttpPort = -1;
    }

    pLogger.log(LogService.LOG_INFO, "HTTP Receiver bound to port="
            + pHttpPort);
    */
}
 

import org.apache.felix.ipojo.annotations.Bind; //导入依赖的package包/类
/**
 * Http Service Availability Checker ready
 * 
 * @param aHttpServiceAvailablityChecker
 * 				The bound service
 */
@Bind(id = BIND_ID_HTTPSERVICE_AVAILABILITY_CHECKER)
private void bindHttpServiceAvailabilityChecker(final IHttpServiceAvailabilityChecker aHttpServiceAvailablityChecker) {
	// update port
	pHttpPort = aHttpServiceAvailablityChecker.getPort();
	pLogger.log(LogService.LOG_INFO, "HTTP Receiver bound to port="
            + pHttpPort);
}