[FELIX-2966] - Annotations should automatically generate Import-Service/Export-Service headers.
[FELIX-2965] - Annotations should allow to enable or disable auto-configuration mode.
git-svn-id: https://svn.apache.org/repos/asf/felix/trunk@1125833 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/dependencymanager/runtime/doc/changelog.txt b/dependencymanager/runtime/doc/changelog.txt
index 7f3eb61..e52d2fb 100644
--- a/dependencymanager/runtime/doc/changelog.txt
+++ b/dependencymanager/runtime/doc/changelog.txt
@@ -6,6 +6,8 @@
** Improvement
* Removed root changelog.txt
* [FELIX-2954 ] - annotated component factory does not allow to provide a component instance explicitly
+ * [FELIX-2966] - Annotations should automatically generate Import-Service/Export-Service headers
+ * [FELIX-2965] - Annotations should allow to enable or disable auto-configuration mode.
Initial Release 3.0.0
---------------------
diff --git a/dependencymanager/runtime/pom.xml b/dependencymanager/runtime/pom.xml
index 3dbe065..ffe4a27 100644
--- a/dependencymanager/runtime/pom.xml
+++ b/dependencymanager/runtime/pom.xml
@@ -27,7 +27,7 @@
</properties>
<name>Apache Felix Dependency Manager Runtime</name>
<artifactId>org.apache.felix.dependencymanager.runtime</artifactId>
- <version>3.0.1-SNAPSHOT</version>
+ <version>3.1.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<dependencies>
<dependency>
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java
index 5c6d453..2127c8e 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java
@@ -18,12 +18,16 @@
*/
package org.apache.felix.dm.runtime;
+import java.lang.reflect.InvocationTargetException;
import java.util.List;
import org.apache.felix.dm.Component;
+import org.apache.felix.dm.ComponentStateListener;
import org.apache.felix.dm.Dependency;
import org.apache.felix.dm.DependencyManager;
import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
/**
* Base class for all kind of DM component builders (for Component, Aspect, Adapters ...).
@@ -49,18 +53,51 @@
/**
* Sets common Service parameters, if provided from our Component descriptor
*/
- protected void setCommonServiceParams(Component service, MetaData serviceMetaData)
+ protected void setCommonServiceParams(Component c, MetaData srvMeta)
throws Exception
{
- String init = serviceMetaData.getString(Params.init, null);
- String start = serviceMetaData.getString(Params.start, null);
- String stop = serviceMetaData.getString(Params.stop, null);
- String destroy = serviceMetaData.getString(Params.destroy, null);
- service.setCallbacks(init, start, stop, destroy);
- String composition = serviceMetaData.getString(Params.composition, null);
- if (composition != null)
+ // Set auto configured component fields.
+ DependencyManager dm = c.getDependencyManager();
+ boolean autoConfigureComponents =
+ "true".equals(dm.getBundleContext().getProperty(Activator.CONF_ENABLE_AUTOCONFIG));
+
+ if (!autoConfigureComponents)
{
- service.setComposition(composition);
+ c.setAutoConfig(BundleContext.class, Boolean.FALSE);
+ c.setAutoConfig(ServiceRegistration.class, Boolean.FALSE);
+ c.setAutoConfig(DependencyManager.class, Boolean.FALSE);
+ c.setAutoConfig(Component.class, Boolean.FALSE);
+ }
+
+ // See if BundleContext must be auto configured.
+ String bundleContextField = srvMeta.getString(Params.bundleContextField, null);
+ if (bundleContextField != null)
+ {
+ c.setAutoConfig(BundleContext.class, bundleContextField);
+ }
+
+ // See if DependencyManager must be auto configured.
+ String dependencyManagerField = srvMeta.getString(Params.dependencyManagerField, null);
+ if (dependencyManagerField != null)
+ {
+ c.setAutoConfig(DependencyManager.class, dependencyManagerField);
+ }
+
+ // See if Component must be auto configured.
+ String componentField = srvMeta.getString(Params.componentField, null);
+ if (componentField != null)
+ {
+ c.setAutoConfig(Component.class, componentField);
+ }
+
+ // Now, if the component has a @Started annotation, then add our component state listener,
+ // which will callback the corresponding annotated method, once the component is started.
+ String registered = srvMeta.getString(Params.registered, null);
+ String unregistered = srvMeta.getString(Params.unregistered, null);
+
+ if (registered != null || unregistered != null)
+ {
+ c.addStateListener(new RegistrationListener(registered, unregistered));
}
}
@@ -85,4 +122,68 @@
}
}
}
+
+ static class RegistrationListener implements ComponentStateListener
+ {
+ private final String m_registered;
+ private String m_unregistered;
+
+ RegistrationListener(String registered, String unregistered)
+ {
+ m_registered = registered;
+ m_unregistered = unregistered;
+ }
+
+ public void starting(Component c)
+ {
+ // No need to invoke any callback here, since it is the ServiceLifecycleHandler
+ // that will invoke the method annotated with @Start
+ }
+
+ public void started(Component c)
+ {
+ if (m_registered != null)
+ {
+ Object instance = c.getService();
+ try
+ {
+ InvocationUtil
+ .invokeCallbackMethod(instance,
+ m_registered,
+ new Class[][] {{ ServiceRegistration.class }, {}},
+ new Object[][] {{ c.getServiceRegistration() }, {}});
+ }
+ catch (Throwable t)
+ {
+ Log.instance().error("Exception caught while invoking method %s on component %s", t, m_registered, instance);
+ }
+ }
+ }
+
+ public void stopping(Component c)
+ {
+ // No need to invoke any callback here, since it is the ServiceLifecycleHandler
+ // that will invoke the method annotated with @Stop
+ }
+
+ public void stopped(Component c)
+ {
+ if (m_unregistered != null)
+ {
+ Object instance = c.getService();
+ try
+ {
+ InvocationUtil
+ .invokeCallbackMethod(instance,
+ m_unregistered,
+ new Class[][] {{}},
+ new Object[][] {{}});
+ }
+ catch (Throwable t)
+ {
+ Log.instance().error("Exception caught while invoking method %s on component %s", t, m_registered, instance);
+ }
+ }
+ }
+ }
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java
index 0ee0bc3..26fe7ef 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java
@@ -35,7 +35,17 @@
*/
public class Activator extends DependencyActivatorBase
{
- private final static String CONF_LOG = "dm.runtime.log";
+ /**
+ * Name of bundle context property telling if log service is required or not.
+ * (default = false)
+ */
+ final static String CONF_LOG = "dm.runtime.log";
+
+ /**
+ * Name of bundle context property telling if Components must be auto configured
+ * with BundleContext/ServiceRegistration etc .. (default = false)
+ */
+ final static String CONF_ENABLE_AUTOCONFIG = "dm.runtime.autoconfig";
/**
* Initialize our DependencyManager Runtime service.
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java
index 2c6a9d5..3b9f807 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java
@@ -64,42 +64,43 @@
throw new IllegalArgumentException("missing added callback");
}
- Component service;
+ Component c;
if (field != null)
{
- service = dm.createAdapterService(adapteeService, adapteeFilter, field);
+ c = dm.createAdapterService(adapteeService, adapteeFilter, field);
}
else
{
if (added != null)
{
- service = dm.createAdapterService(adapteeService, adapteeFilter, added, changed, removed);
+ c = dm.createAdapterService(adapteeService, adapteeFilter, added, changed, removed);
}
else
{
- service = dm.createAdapterService(adapteeService, adapteeFilter);
+ c = dm.createAdapterService(adapteeService, adapteeFilter);
}
}
- service.setInterface(provides, adapterProperties);
+ setCommonServiceParams(c, srvMeta);
+ c.setInterface(provides, adapterProperties);
String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
if (factoryMethod == null)
{
- service.setImplementation(adapterImplClass);
+ c.setImplementation(adapterImplClass);
}
else
{
- service.setFactory(adapterImplClass, factoryMethod);
+ c.setFactory(adapterImplClass, factoryMethod);
}
- service.setComposition(srvMeta.getString(Params.composition, null));
- ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(service, b, dm, srvMeta, depsMeta);
+ c.setComposition(srvMeta.getString(Params.composition, null));
+ ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
// The dependencies will be plugged by our lifecycle handler.
- service.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+ c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
// Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
- addUnamedDependencies(b, dm, service, srvMeta, depsMeta);
- dm.add(service);
+ addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+ dm.add(c);
}
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java
index f73099a..de4520b 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java
@@ -69,47 +69,45 @@
throw new IllegalArgumentException("missing added callback");
}
- Component service;
+ Component c;
if (field != null)
{
- service =
- dm.createAspectService(serviceInterface, serviceFilter, ranking, field)
- .setServiceProperties(aspectProperties);
+ c = dm.createAspectService(serviceInterface, serviceFilter, ranking, field)
+ .setServiceProperties(aspectProperties);
}
else
{
if (added != null)
{
- service =
- dm.createAspectService(serviceInterface, serviceFilter, ranking, added, changed, removed)
- .setServiceProperties(aspectProperties);
+ c = dm.createAspectService(serviceInterface, serviceFilter, ranking, added, changed, removed)
+ .setServiceProperties(aspectProperties);
}
else
{
- service =
- dm.createAspectService(serviceInterface, serviceFilter, ranking)
- .setServiceProperties(aspectProperties);
+ c = dm.createAspectService(serviceInterface, serviceFilter, ranking)
+ .setServiceProperties(aspectProperties);
}
}
+ setCommonServiceParams(c, srvMeta);
String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
if (factoryMethod == null)
{
- service.setImplementation(implClass);
+ c.setImplementation(implClass);
}
else
{
- service.setFactory(implClass, factoryMethod);
+ c.setFactory(implClass, factoryMethod);
}
- service.setComposition(srvMeta.getString(Params.composition, null));
- ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(service, b, dm, srvMeta, depsMeta);
+ c.setComposition(srvMeta.getString(Params.composition, null));
+ ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
// The dependencies will be plugged by our lifecycle handler.
- service.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+ c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
// Adds dependencies (except named dependencies, which are managed by the lifecycle
// handler).
- addUnamedDependencies(b, dm, service, srvMeta, depsMeta);
- dm.add(service);
+ addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+ dm.add(c);
}
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java
index a093c01..94f8e62 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java
@@ -51,24 +51,25 @@
String[] provides = srvMeta.getStrings(Params.provides, null);
Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
boolean propagate = "true".equals(srvMeta.getString(Params.propagate, "false"));
- Component srv = dm.createBundleAdapterService(stateMask, filter, propagate);
- srv.setInterface(provides, properties);
+ Component c = dm.createBundleAdapterService(stateMask, filter, propagate);
+ c.setInterface(provides, properties);
String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
if (factoryMethod == null)
{
- srv.setImplementation(adapterImplClass);
+ c.setImplementation(adapterImplClass);
}
else
{
- srv.setFactory(adapterImplClass, factoryMethod);
+ c.setFactory(adapterImplClass, factoryMethod);
}
- srv.setComposition(srvMeta.getString(Params.composition, null));
- ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(srv, b, dm, srvMeta, depsMeta);
+ setCommonServiceParams(c, srvMeta);
+ c.setComposition(srvMeta.getString(Params.composition, null));
+ ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
// The dependencies will be plugged by our lifecycle handler.
- srv.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+ c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
// Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
- addUnamedDependencies(b, dm, srv, srvMeta, depsMeta);
- dm.add(srv);
+ addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+ dm.add(c);
}
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java
index 9068005..aa0d60f 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java
@@ -26,6 +26,8 @@
import org.apache.felix.dm.Component;
import org.apache.felix.dm.DependencyManager;
import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
/**
* Builds a DependencyManager Component.
@@ -47,10 +49,13 @@
public void build(MetaData srvMeta, List<MetaData> depsMeta, Bundle b, DependencyManager dm)
throws Exception
{
- Component service = dm.createComponent();
+ Component c = dm.createComponent();
String factory = srvMeta.getString(Params.factorySet, null);
- // Check if we must provide a Set Factory.
+ // Setup Component auto config fields
+ setCommonServiceParams(c, srvMeta);
+
+ // Check if we must provide a Component factory set.
if (factory == null)
{
Log.instance().info("ComponentBuilder: building service %s with dependencies %s",
@@ -62,26 +67,26 @@
String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
if (factoryMethod == null)
{
- service.setImplementation(b.loadClass(impl));
+ c.setImplementation(b.loadClass(impl));
}
else
{
- service.setFactory(b.loadClass(impl), factoryMethod);
+ c.setFactory(b.loadClass(impl), factoryMethod);
}
- service.setComposition(composition);
+ c.setComposition(composition);
// Adds dependencies (except named dependencies, which are managed by the lifecycle
// handler).
- addUnamedDependencies(b, dm, service, srvMeta, depsMeta);
+ addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
// Creates a ServiceHandler, which will filter all service lifecycle callbacks.
ServiceLifecycleHandler lfcleHandler =
- new ServiceLifecycleHandler(service, b, dm, srvMeta, depsMeta);
- service.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+ new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
+ c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
// Set the provided services
Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
String[] services = srvMeta.getStrings(Params.provides, null);
- service.setInterface(services, properties);
+ c.setInterface(services, properties);
}
else
{
@@ -94,13 +99,13 @@
// This Set will act as a factory and another component may registers some
// service configurations into it in order to fire some service instantiations.
FactorySet factorySet = new FactorySet(b, srvMeta, depsMeta);
- service.setImplementation(factorySet);
- service.setCallbacks(null, "start", "stop", null);
+ c.setImplementation(factorySet);
+ c.setCallbacks(null, "start", "stop", null);
Hashtable<String, String> props = new Hashtable<String, String>();
props.put(DM_FACTORY_NAME, factory);
- service.setInterface(Set.class.getName(), props);
+ c.setInterface(Set.class.getName(), props);
}
- dm.add(service);
+ dm.add(c);
}
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java
index 2576c75..0f4eb09 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java
@@ -51,23 +51,24 @@
String[] provides = srvMeta.getStrings(Params.provides, null);
Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
boolean propagate = "true".equals(srvMeta.getString(Params.propagate, "false"));
- Component srv = dm.createFactoryConfigurationAdapterService(factoryPid, updated, propagate);
- srv.setInterface(provides, properties);
+ Component c = dm.createFactoryConfigurationAdapterService(factoryPid, updated, propagate);
+ c.setInterface(provides, properties);
String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
if (factoryMethod == null)
{
- srv.setImplementation(implClass);
+ c.setImplementation(implClass);
}
else
{
- srv.setFactory(implClass, factoryMethod);
+ c.setFactory(implClass, factoryMethod);
}
- srv.setComposition(srvMeta.getString(Params.composition, null));
- ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(srv, b, dm, srvMeta, depsMeta);
+ setCommonServiceParams(c, srvMeta);
+ c.setComposition(srvMeta.getString(Params.composition, null));
+ ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
// The dependencies will be plugged by our lifecycle handler.
- srv.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+ c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
// Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
- addUnamedDependencies(b, dm, srv, srvMeta, depsMeta);
- dm.add(srv);
+ addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+ dm.add(c);
}
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java
index a035c1e..8241b6d 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java
@@ -81,9 +81,9 @@
private List<MetaData> m_depsMeta;
/**
- * The DependencyManager (injected by reflection), which is used to create Service instances.
+ * The DependencyManager which is used to create Service instances.
*/
- private DependencyManager m_dm; // Injected
+ private DependencyManager m_dm;
/**
* This class is used to serialize concurrent method calls, and allow to leave our methods unsynchronized.
@@ -173,9 +173,10 @@
/**
* Our Service is starting.
*/
- public void start()
+ public void start(Component c)
{
m_active = true;
+ m_dm = c.getDependencyManager();
}
/**
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java
index 5cee9d6..7f0637f 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java
@@ -57,5 +57,10 @@
name,
field,
starter,
- stopper
+ stopper,
+ bundleContextField,
+ dependencyManagerField,
+ componentField,
+ registered,
+ unregistered
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java
index 2e99dd2..7174396 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java
@@ -51,23 +51,24 @@
Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
boolean propagate = "true".equals(srvMeta.getString(Params.propagate, "false"));
String changed = srvMeta.getString(Params.changed, null /* no change callback if not specified explicitly */);
- Component srv = dm.createResourceAdapterService(filter, propagate, null, changed);
- srv.setInterface(provides, properties);
+ Component c = dm.createResourceAdapterService(filter, propagate, null, changed);
+ c.setInterface(provides, properties);
String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
if (factoryMethod == null)
{
- srv.setImplementation(implClass);
+ c.setImplementation(implClass);
}
else
{
- srv.setFactory(implClass, factoryMethod);
+ c.setFactory(implClass, factoryMethod);
}
- srv.setComposition(srvMeta.getString(Params.composition, null));
- ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(srv, b, dm, srvMeta, depsMeta);
+ setCommonServiceParams(c, srvMeta);
+ c.setComposition(srvMeta.getString(Params.composition, null));
+ ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
// The dependencies will be plugged by our lifecycle handler.
- srv.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+ c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
// Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
- addUnamedDependencies(b, dm, srv, srvMeta, depsMeta);
- dm.add(srv);
+ addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+ dm.add(c);
}
}
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java
index b25485f..90ff707 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java
@@ -332,17 +332,16 @@
/**
* Invoke a callback on an Object instance.
*/
- private Object invokeMethod(Object serviceInstance, String method, DependencyManager dm, Component service)
+ private Object invokeMethod(Object serviceInstance, String method, DependencyManager dm, Component c)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
if (method != null)
{
try
{
- return InvocationUtil.invokeCallbackMethod(
- serviceInstance, method,
+ return InvocationUtil.invokeCallbackMethod(serviceInstance, method,
new Class[][] { { Component.class }, {} },
- new Object[][] { { service }, {} }
+ new Object[][] { { c }, {} }
);
}